From d63bd6d60d9c306bfa8fb0c62f4d9e639c67e721 Mon Sep 17 00:00:00 2001 From: Seth Rickard Date: Thu, 27 Jan 2022 13:03:19 -0600 Subject: [PATCH 01/14] implement CC13X2 CC26X2 OTA feature with ext flash * add OTA clusters to doorlock example * Implement OTA platform code for cc13x2x7_26x2x7 * update cc13x2x7_26x2x7 doorlock example to initialize the OTA driver * update cc13x2x7_26x2x7 applications to an OTA enabled linkerscript * create merge tool for the OTA image and the BIM pre-built hexfile --- examples/lock-app/cc13x2x7_26x2x7/BUILD.gn | 12 - examples/lock-app/cc13x2x7_26x2x7/args.gni | 4 +- examples/lock-app/cc13x2x7_26x2x7/chip.syscfg | 16 +- .../lock-app/cc13x2x7_26x2x7/main/AppTask.cpp | 34 +- examples/lock-app/lock-common/BUILD.gn | 0 examples/lock-app/lock-common/lock-app.matter | 136 ++++++ examples/lock-app/lock-common/lock-app.zap | 275 +++++++++++ .../cc13x2x7_26x2x7/BUILD.gn | 9 - examples/pump-app/cc13x2x7_26x2x7/BUILD.gn | 11 - .../cc13x2x7_26x2x7/BUILD.gn | 11 - src/platform/cc13x2_26x2/BUILD.gn | 10 + src/platform/cc13x2_26x2/CHIPPlatformConfig.h | 2 +- .../cc13x2_26x2/OTAImageProcessorImpl.cpp | 436 ++++++++++++++++++ .../cc13x2_26x2/OTAImageProcessorImpl.h | 66 +++ .../cc13x2x7_cc26x2x7_freertos_ota.lds | 282 +++++++++++ src/platform/cc13x2_26x2/oad_image_header.c | 81 ++++ third_party/ti_simplelink_sdk/run_oad_tool.py | 56 +++ .../ti_simplelink_sdk/ti_simplelink_board.gni | 3 + .../ti_simplelink_executable.gni | 86 +++- .../zap-generated/CHIPClientCallbacks.cpp | 156 +++++++ .../zap-generated/CHIPClientCallbacks.h | 24 + .../lock-app/zap-generated/CHIPClusters.cpp | 170 +++++++ .../lock-app/zap-generated/CHIPClusters.h | 33 ++ .../zap-generated/IMClusterCommandHandler.cpp | 237 ++++++++++ .../PluginApplicationCallbacks.h | 2 + .../lock-app/zap-generated/af-gen-event.h | 0 .../lock-app/zap-generated/callback-stub.cpp | 16 + .../lock-app/zap-generated/endpoint_config.h | 63 ++- .../lock-app/zap-generated/gen_config.h | 11 + .../lock-app/zap-generated/gen_tokens.h | 0 30 files changed, 2162 insertions(+), 80 deletions(-) mode change 100644 => 100755 examples/lock-app/lock-common/BUILD.gn mode change 100644 => 100755 examples/lock-app/lock-common/lock-app.matter mode change 100644 => 100755 examples/lock-app/lock-common/lock-app.zap create mode 100644 src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp create mode 100644 src/platform/cc13x2_26x2/OTAImageProcessorImpl.h create mode 100644 src/platform/cc13x2_26x2/cc13x2x7_cc26x2x7_freertos_ota.lds create mode 100644 src/platform/cc13x2_26x2/oad_image_header.c create mode 100644 third_party/ti_simplelink_sdk/run_oad_tool.py mode change 100644 => 100755 zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.cpp mode change 100644 => 100755 zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.h mode change 100644 => 100755 zzz_generated/lock-app/zap-generated/CHIPClusters.cpp mode change 100644 => 100755 zzz_generated/lock-app/zap-generated/CHIPClusters.h mode change 100644 => 100755 zzz_generated/lock-app/zap-generated/IMClusterCommandHandler.cpp mode change 100644 => 100755 zzz_generated/lock-app/zap-generated/PluginApplicationCallbacks.h mode change 100644 => 100755 zzz_generated/lock-app/zap-generated/af-gen-event.h mode change 100644 => 100755 zzz_generated/lock-app/zap-generated/callback-stub.cpp mode change 100644 => 100755 zzz_generated/lock-app/zap-generated/endpoint_config.h mode change 100644 => 100755 zzz_generated/lock-app/zap-generated/gen_config.h mode change 100644 => 100755 zzz_generated/lock-app/zap-generated/gen_tokens.h diff --git a/examples/lock-app/cc13x2x7_26x2x7/BUILD.gn b/examples/lock-app/cc13x2x7_26x2x7/BUILD.gn index fe6c006de15aeb..2636803899e2ab 100644 --- a/examples/lock-app/cc13x2x7_26x2x7/BUILD.gn +++ b/examples/lock-app/cc13x2x7_26x2x7/BUILD.gn @@ -43,7 +43,6 @@ ti_sysconfig("sysconfig") { sources = [ "${project_dir}/chip.syscfg" ] outputs = [ - "ti_devices_config.c", "ti_radio_config.c", "ti_radio_config.h", "ti_drivers_config.c", @@ -111,17 +110,6 @@ ti_simplelink_executable("lock_app") { "-Wconversion", ] - ldscript = "${ti_simplelink_sdk_root}/source/ti/dmm/apps/common/freertos/cc13x2x7_cc26x2x7.lds" - - inputs = [ ldscript ] - - ldflags = [ - "-L${ti_simplelink_sdk_root}/source", - rebase_path("${target_gen_dir}/sysconfig/ti_utils_build_linker.cmd.genlibs", - root_build_dir), - "-T" + rebase_path(ldscript, root_build_dir), - ] - output_dir = root_out_dir } diff --git a/examples/lock-app/cc13x2x7_26x2x7/args.gni b/examples/lock-app/cc13x2x7_26x2x7/args.gni index 5b402aef6a410b..6abffce95b189d 100644 --- a/examples/lock-app/cc13x2x7_26x2x7/args.gni +++ b/examples/lock-app/cc13x2x7_26x2x7/args.gni @@ -23,7 +23,9 @@ ti_simplelink_board = "LP_CC2652R7" # Size Optimizations # use -Os instead of -Og, LWIP release build -#is_debug = false +is_debug = false + +chip_enable_ota_requestor = true # Disable CHIP Logging #chip_progress_logging = false diff --git a/examples/lock-app/cc13x2x7_26x2x7/chip.syscfg b/examples/lock-app/cc13x2x7_26x2x7/chip.syscfg index f195ca15ec32d7..7ad5ad12df4fbb 100644 --- a/examples/lock-app/cc13x2x7_26x2x7/chip.syscfg +++ b/examples/lock-app/cc13x2x7_26x2x7/chip.syscfg @@ -45,6 +45,7 @@ var Button1 = Button.addInstance(); var Button2 = Button.addInstance(); var ECJPAKE = ECJPAKE.addInstance(); var NVS1 = NVS.addInstance(); +var NVS2 = NVS.addInstance(); var SHA21 = SHA2.addInstance(); var LED1 = LED.addInstance(); var LED2 = LED.addInstance(); @@ -84,23 +85,26 @@ Button2.gpioPin.interruptTrigger = "Falling Edge"; /* ======== CCFG ======== */ var CCFG = scripting.addModule("/ti/devices/CCFG"); -const deviceName = system.getScript("/ti/ti154stack/ti154stack_common.js").getLaunchPadFromDevice(); const ccfgSettings = system.getScript("/ti/common/lprf_ccfg_settings.js").ccfgSettings; for(var setting in ccfgSettings) { CCFG[setting] = ccfgSettings[setting]; } -// Update LF Clock Source for CC2652RB devices -if(deviceName.includes("RB")) -{ - CCFG.srcClkLF = "Derived from HF XOSC"; -} +// Disable CCFG generation, this is added by the BIM project +CCFG.enableCodeGeneration = false; + /* NVS */ NVS1.$name = "CONFIG_NVSINTERNAL"; NVS1.internalFlash.regionBase = 0xAA000; NVS1.internalFlash.regionSize = 0x4000; +NVS2.$name = "CONFIG_NVSEXTERNAL"; +NVS2.nvsType = "External"; // NVS Region Type +NVS2.$hardware = system.deviceData.board.components.MX25R8035F; +NVS2.externalFlash.verifyBufferSize = 64; // Write Verification Buffer size (in bytes) +NVS2.externalFlash.regionSize = 0x256000; // Size of Region (in bytes) + /* RF */ /* if an antenna component exists, assign it to the rf instance */ if (system.deviceData.board && system.deviceData.board.components.RF) { diff --git a/examples/lock-app/cc13x2x7_26x2x7/main/AppTask.cpp b/examples/lock-app/cc13x2x7_26x2x7/main/AppTask.cpp index 8649f916b3ebb1..6e9ce8e4e4f8b4 100644 --- a/examples/lock-app/cc13x2x7_26x2x7/main/AppTask.cpp +++ b/examples/lock-app/cc13x2x7_26x2x7/main/AppTask.cpp @@ -27,9 +27,14 @@ #include #include +#include + +#include +#include #include #include -#include +#include +#include #include @@ -43,6 +48,7 @@ #define APP_TASK_PRIORITY 4 #define APP_EVENT_QUEUE_SIZE 10 +using namespace ::chip; using namespace ::chip::Credentials; using namespace ::chip::DeviceLayer; @@ -56,6 +62,22 @@ static Button_Handle sAppRightHandle; AppTask AppTask::sAppTask; +static OTARequestor sRequestorCore; +static GenericOTARequestorDriver sRequestorUser; +static BDXDownloader sDownloader; +static OTAImageProcessorImpl sImageProcessor; + +void InitializeOTARequestor(void) +{ + // Initialize and interconnect the Requestor and Image Processor objects + SetRequestorInstance(&sRequestorCore); + + sRequestorCore.Init(&Server::GetInstance(), &sRequestorUser, &sDownloader); + sImageProcessor.SetOTADownloader(&sDownloader); + sDownloader.SetImageProcessorDelegate(&sImageProcessor); + sRequestorUser.Init(&sRequestorCore, &sImageProcessor); +} + int AppTask::StartAppTask() { int ret = 0; @@ -87,7 +109,7 @@ int AppTask::Init() cc13x2_26x2LogInit(); // Init Chip memory management before the stack - chip::Platform::MemoryInit(); + Platform::MemoryInit(); CHIP_ERROR ret = PlatformMgr().InitChipStack(); if (ret != CHIP_NO_ERROR) @@ -131,7 +153,7 @@ int AppTask::Init() // Init ZCL Data Model and start server PLAT_LOG("Initialize Server"); - chip::Server::GetInstance().Init(); + Server::GetInstance().Init(); // Initialize device attestation config SetDeviceAttestationCredentialsProvider(Examples::GetExampleDACProvider()); @@ -172,8 +194,10 @@ int AppTask::Init() ConfigurationMgr().LogDeviceConfig(); + InitializeOTARequestor(); + // QR code will be used with CHIP Tool - PrintOnboardingCodes(chip::RendezvousInformationFlags(chip::RendezvousInformationFlag::kBLE)); + PrintOnboardingCodes(RendezvousInformationFlags(RendezvousInformationFlag::kBLE)); return 0; } @@ -322,7 +346,7 @@ void AppTask::DispatchEvent(AppEvent * aEvent) // Enable BLE advertisements if (!ConnectivityMgr().IsBLEAdvertisingEnabled()) { - if (chip::Server::GetInstance().GetCommissioningWindowManager().OpenBasicCommissioningWindow() == CHIP_NO_ERROR) + if (Server::GetInstance().GetCommissioningWindowManager().OpenBasicCommissioningWindow() == CHIP_NO_ERROR) { PLAT_LOG("Enabled BLE Advertisement"); } diff --git a/examples/lock-app/lock-common/BUILD.gn b/examples/lock-app/lock-common/BUILD.gn old mode 100644 new mode 100755 diff --git a/examples/lock-app/lock-common/lock-app.matter b/examples/lock-app/lock-common/lock-app.matter old mode 100644 new mode 100755 index 170cbf2a12ed7e..ab4bfed7192686 --- a/examples/lock-app/lock-common/lock-app.matter +++ b/examples/lock-app/lock-common/lock-app.matter @@ -426,6 +426,140 @@ server cluster NetworkCommissioning = 49 { command ScanNetworks(ScanNetworksRequest): ScanNetworksResponse = 0; } +client cluster OtaSoftwareUpdateProvider = 41 { + enum OTAApplyUpdateAction : ENUM8 { + kProceed = 0; + kAwaitNextAction = 1; + kDiscontinue = 2; + } + + enum OTADownloadProtocol : ENUM8 { + kBDXSynchronous = 0; + kBDXAsynchronous = 1; + kHttps = 2; + kVendorSpecific = 3; + } + + enum OTAQueryStatus : ENUM8 { + kUpdateAvailable = 0; + kBusy = 1; + kNotAvailable = 2; + kDownloadProtocolNotSupported = 3; + } + + readonly global attribute int16u clusterRevision = 65533; + + request struct ApplyUpdateRequestRequest { + OCTET_STRING updateToken = 0; + INT32U newVersion = 1; + } + + request struct NotifyUpdateAppliedRequest { + OCTET_STRING updateToken = 0; + INT32U softwareVersion = 1; + } + + request struct QueryImageRequest { + vendor_id vendorId = 0; + INT16U productId = 1; + INT32U softwareVersion = 2; + OTADownloadProtocol protocolsSupported[] = 3; + optional INT16U hardwareVersion = 4; + optional CHAR_STRING location = 5; + optional BOOLEAN requestorCanConsent = 6; + optional OCTET_STRING metadataForProvider = 7; + } + + response struct ApplyUpdateResponse { + OTAApplyUpdateAction action = 0; + INT32U delayedActionTime = 1; + } + + response struct QueryImageResponse { + OTAQueryStatus status = 0; + optional INT32U delayedActionTime = 1; + optional CHAR_STRING imageURI = 2; + optional INT32U softwareVersion = 3; + optional CHAR_STRING softwareVersionString = 4; + optional OCTET_STRING updateToken = 5; + optional BOOLEAN userConsentNeeded = 6; + optional OCTET_STRING metadataForRequestor = 7; + } + + command ApplyUpdateRequest(ApplyUpdateRequestRequest): ApplyUpdateResponse = 2; + command NotifyUpdateApplied(NotifyUpdateAppliedRequest): DefaultSuccess = 4; + command QueryImage(QueryImageRequest): QueryImageResponse = 0; +} + +server cluster OtaSoftwareUpdateRequestor = 42 { + enum OTAAnnouncementReason : ENUM8 { + kSimpleAnnouncement = 0; + kUpdateAvailable = 1; + kUrgentUpdateAvailable = 2; + } + + enum OTAChangeReasonEnum : ENUM8 { + kUnknown = 0; + kSuccess = 1; + kFailure = 2; + kTimeOut = 3; + kDelayByProvider = 4; + } + + enum OTAUpdateStateEnum : ENUM8 { + kUnknown = 0; + kIdle = 1; + kQuerying = 2; + kDelayedOnQuery = 3; + kDownloading = 4; + kApplying = 5; + kDelayedOnApply = 6; + kRollingBack = 7; + kDelayedOnUserConsent = 8; + } + + struct ProviderLocation { + fabric_idx fabricIndex = 0; + node_id providerNodeID = 1; + endpoint_no endpoint = 2; + } + + info event StateTransition = 0 { + nullable OTAUpdateStateEnum previousState = 0; + OTAUpdateStateEnum newState = 1; + OTAChangeReasonEnum reason = 2; + nullable INT32U targetSoftwareVersion = 3; + } + + critical event VersionApplied = 1 { + INT32U softwareVersion = 0; + INT16U productID = 1; + } + + info event DownloadError = 2 { + INT32U softwareVersion = 0; + INT64U bytesDownloaded = 1; + nullable INT8U progressPercent = 2; + nullable INT64S platformCode = 3; + } + + attribute ProviderLocation defaultOtaProviders[] = 0; + readonly attribute boolean updatePossible = 1; + readonly attribute OTAUpdateStateEnum updateState = 2; + readonly attribute nullable int8u updateStateProgress = 3; + readonly global attribute int16u clusterRevision = 65533; + + request struct AnnounceOtaProviderRequest { + node_id providerNodeId = 0; + vendor_id vendorId = 1; + OTAAnnouncementReason announcementReason = 2; + optional OCTET_STRING metadataForNode = 3; + endpoint_no endpoint = 4; + } + + command AnnounceOtaProvider(AnnounceOtaProviderRequest): DefaultSuccess = 0; +} + server cluster OnOff = 6 { enum OnOffDelayedAllOffEffectVariant : enum8 { kFadeToOffIn0p8Seconds = 0; @@ -910,6 +1044,8 @@ endpoint 0 { server cluster GeneralDiagnostics; server cluster LocalizationConfiguration; server cluster NetworkCommissioning; + binding cluster OtaSoftwareUpdateProvider; + server cluster OtaSoftwareUpdateRequestor; server cluster OperationalCredentials; server cluster PowerSource; server cluster PowerSourceConfiguration; diff --git a/examples/lock-app/lock-common/lock-app.zap b/examples/lock-app/lock-common/lock-app.zap old mode 100644 new mode 100755 index 2f137a017ef6f3..85ee0562d5a505 --- a/examples/lock-app/lock-common/lock-app.zap +++ b/examples/lock-app/lock-common/lock-app.zap @@ -1279,6 +1279,281 @@ } ] }, + { + "name": "OTA Software Update Provider", + "code": 41, + "mfgCode": null, + "define": "OTA_PROVIDER_CLUSTER", + "side": "client", + "enabled": 1, + "commands": [ + { + "name": "QueryImage", + "code": 0, + "mfgCode": null, + "source": "client", + "incoming": 0, + "outgoing": 1 + }, + { + "name": "ApplyUpdateRequest", + "code": 2, + "mfgCode": null, + "source": "client", + "incoming": 0, + "outgoing": 1 + }, + { + "name": "NotifyUpdateApplied", + "code": 4, + "mfgCode": null, + "source": "client", + "incoming": 0, + "outgoing": 1 + } + ], + "attributes": [ + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "client", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0x0001", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, + { + "name": "OTA Software Update Provider", + "code": 41, + "mfgCode": null, + "define": "OTA_PROVIDER_CLUSTER", + "side": "server", + "enabled": 0, + "commands": [ + { + "name": "QueryImageResponse", + "code": 1, + "mfgCode": null, + "source": "server", + "incoming": 1, + "outgoing": 0 + }, + { + "name": "ApplyUpdateResponse", + "code": 3, + "mfgCode": null, + "source": "server", + "incoming": 1, + "outgoing": 0 + } + ], + "attributes": [ + { + "name": "AttributeList", + "code": 65531, + "mfgCode": null, + "side": "server", + "included": 0, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 0, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "included": 0, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 0, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0x0001", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, + { + "name": "OTA Software Update Requestor", + "code": 42, + "mfgCode": null, + "define": "OTA_REQUESTOR_CLUSTER", + "side": "client", + "enabled": 0, + "commands": [ + { + "name": "AnnounceOtaProvider", + "code": 0, + "mfgCode": null, + "source": "client", + "incoming": 1, + "outgoing": 0 + } + ], + "attributes": [ + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "client", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, + { + "name": "OTA Software Update Requestor", + "code": 42, + "mfgCode": null, + "define": "OTA_REQUESTOR_CLUSTER", + "side": "server", + "enabled": 1, + "commands": [], + "attributes": [ + { + "name": "DefaultOtaProviders", + "code": 0, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "External", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "UpdatePossible", + "code": 1, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "UpdateState", + "code": 2, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + }, + { + "name": "UpdateStateProgress", + "code": 3, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "AttributeList", + "code": 65531, + "mfgCode": null, + "side": "server", + "included": 0, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "FeatureMap", + "code": 65532, + "mfgCode": null, + "side": "server", + "included": 0, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "0", + "reportable": 1, + "minInterval": 1, + "maxInterval": 65534, + "reportableChange": 0 + }, + { + "name": "ClusterRevision", + "code": 65533, + "mfgCode": null, + "side": "server", + "included": 1, + "storageOption": "RAM", + "singleton": 0, + "bounded": 0, + "defaultValue": "1", + "reportable": 1, + "minInterval": 0, + "maxInterval": 65344, + "reportableChange": 0 + } + ] + }, { "name": "Localization Configuration", "code": 43, diff --git a/examples/persistent-storage/cc13x2x7_26x2x7/BUILD.gn b/examples/persistent-storage/cc13x2x7_26x2x7/BUILD.gn index 26088b371f4386..ea0acea00155be 100644 --- a/examples/persistent-storage/cc13x2x7_26x2x7/BUILD.gn +++ b/examples/persistent-storage/cc13x2x7_26x2x7/BUILD.gn @@ -82,15 +82,6 @@ ti_simplelink_executable("persistent_storage") { "-Wconversion", ] - ldscript = "${ti_simplelink_sdk_root}/source/ti/dmm/apps/common/freertos/cc13x2x7_cc26x2x7.lds" - - inputs = [ ldscript ] - - ldflags = [ - "-L${ti_simplelink_sdk_root}/source", - "-T" + rebase_path(ldscript, root_build_dir), - ] - output_dir = root_out_dir } diff --git a/examples/pump-app/cc13x2x7_26x2x7/BUILD.gn b/examples/pump-app/cc13x2x7_26x2x7/BUILD.gn index d623d0f5c3c996..63cd58da9dace1 100644 --- a/examples/pump-app/cc13x2x7_26x2x7/BUILD.gn +++ b/examples/pump-app/cc13x2x7_26x2x7/BUILD.gn @@ -110,17 +110,6 @@ ti_simplelink_executable("pump_app") { "-Wconversion", ] - ldscript = "${ti_simplelink_sdk_root}/source/ti/dmm/apps/common/freertos/cc13x2x7_cc26x2x7.lds" - - inputs = [ ldscript ] - - ldflags = [ - "-L${ti_simplelink_sdk_root}/source", - rebase_path("${target_gen_dir}/sysconfig/ti_utils_build_linker.cmd.genlibs", - root_build_dir), - "-T" + rebase_path(ldscript, root_build_dir), - ] - output_dir = root_out_dir } diff --git a/examples/pump-controller-app/cc13x2x7_26x2x7/BUILD.gn b/examples/pump-controller-app/cc13x2x7_26x2x7/BUILD.gn index 445fddb705eaa2..fedefd4dcb5d5d 100644 --- a/examples/pump-controller-app/cc13x2x7_26x2x7/BUILD.gn +++ b/examples/pump-controller-app/cc13x2x7_26x2x7/BUILD.gn @@ -111,17 +111,6 @@ ti_simplelink_executable("pump_controller_app") { "-Wconversion", ] - ldscript = "${ti_simplelink_sdk_root}/source/ti/dmm/apps/common/freertos/cc13x2x7_cc26x2x7.lds" - - inputs = [ ldscript ] - - ldflags = [ - "-L${ti_simplelink_sdk_root}/source", - rebase_path("${target_gen_dir}/sysconfig/ti_utils_build_linker.cmd.genlibs", - root_build_dir), - "-T" + rebase_path(ldscript, root_build_dir), - ] - output_dir = root_out_dir } diff --git a/src/platform/cc13x2_26x2/BUILD.gn b/src/platform/cc13x2_26x2/BUILD.gn index e77d1e99170467..d110cb240eb81b 100644 --- a/src/platform/cc13x2_26x2/BUILD.gn +++ b/src/platform/cc13x2_26x2/BUILD.gn @@ -63,6 +63,16 @@ static_library("cc13x2_26x2") { ] } + if (chip_enable_ota_requestor) { + sources += [ + # this needs to be in the final link to place the data correctly + # see ${chip_root}/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni + #"oad_image_header.c", + "OTAImageProcessorImpl.cpp", + "OTAImageProcessorImpl.h", + ] + } + if (chip_enable_openthread) { # needed for MTD/FTD import("//build_overrides/ti_simplelink_sdk.gni") diff --git a/src/platform/cc13x2_26x2/CHIPPlatformConfig.h b/src/platform/cc13x2_26x2/CHIPPlatformConfig.h index 674bd48d6401d0..c9ddcb00b078ec 100644 --- a/src/platform/cc13x2_26x2/CHIPPlatformConfig.h +++ b/src/platform/cc13x2_26x2/CHIPPlatformConfig.h @@ -30,7 +30,7 @@ // ==================== General Platform Adaptations ==================== -#define CHIP_CONFIG_ABORT() assert() +#define CHIP_CONFIG_ABORT() abort() #define CHIP_CONFIG_PERSISTED_STORAGE_KEY_TYPE uint16_t #define CHIP_CONFIG_PERSISTED_STORAGE_ENC_MSG_CNTR_ID 1 diff --git a/src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp b/src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp new file mode 100644 index 00000000000000..ed3705d7663415 --- /dev/null +++ b/src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp @@ -0,0 +1,436 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "OTAImageProcessorImpl.h" + +#include +#include + +#include + +// clang-format off +/* driverlib header for resetting the SoC */ +#include +#include DeviceFamily_constructPath(driverlib/sys_ctrl.h) +// clang-format on + +namespace chip { + +CHIP_ERROR OTAImageProcessorImpl::PrepareDownload() +{ + DeviceLayer::PlatformMgr().ScheduleWork(HandlePrepareDownload, reinterpret_cast(this)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR OTAImageProcessorImpl::Finalize() +{ + DeviceLayer::PlatformMgr().ScheduleWork(HandleFinalize, reinterpret_cast(this)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR OTAImageProcessorImpl::Apply() +{ + DeviceLayer::PlatformMgr().ScheduleWork(HandleApply, reinterpret_cast(this)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR OTAImageProcessorImpl::Abort() +{ + DeviceLayer::PlatformMgr().ScheduleWork(HandleAbort, reinterpret_cast(this)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR OTAImageProcessorImpl::ProcessBlock(ByteSpan & block) +{ + if (nullptr == mNvsHandle) + { + return CHIP_ERROR_INTERNAL; + } + + if ((nullptr == block.data()) || block.empty()) + { + return CHIP_ERROR_INVALID_ARGUMENT; + } + + // Store block data for HandleProcessBlock to access + CHIP_ERROR err = SetBlock(block); + if (err != CHIP_NO_ERROR) + { + ChipLogError(SoftwareUpdate, "Cannot set block data: %" CHIP_ERROR_FORMAT, err.Format()); + } + + DeviceLayer::PlatformMgr().ScheduleWork(HandleProcessBlock, reinterpret_cast(this)); + return CHIP_NO_ERROR; +} + +/* DESIGN NOTE: The Boot Image Manager will search external flash for an + * `ExtImageInfo_t` structure every 4K for 1M. This structure points to where + * the executable image is in external flash with a uint32_t. It is possible to + * have multiple images ready to be programmed into the internal flash of the + * device. This design is only concerned with managing 1 image in external + * flash starting at `IMG_START` and being defined by a meta header at address + * 0. Future designs may be able to take advantage of other images for + * rollback functionality. + */ + +#define IMG_START (4 * EFL_SIZE_META) + +static bool readExtFlashImgHeader(NVS_Handle handle, imgFixedHdr_t * header) +{ + int_fast16_t status; + status = NVS_read(handle, IMG_START, header, sizeof(header)); + return (status == NVS_STATUS_SUCCESS); +} + +static bool eraseExtFlashHeader(NVS_Handle handle) +{ + int_fast16_t status; + NVS_Attrs regionAttrs; + unsigned int sectors; + + NVS_getAttrs(handle, ®ionAttrs); + /* calculate the number of sectors to erase */ + sectors = (sizeof(imgFixedHdr_t) + (regionAttrs.sectorSize - 1)) / regionAttrs.sectorSize; + status = NVS_erase(handle, IMG_START, sectors * regionAttrs.sectorSize); + + return (status == NVS_STATUS_SUCCESS); +} + +/* makes room for the new block if needed */ +static bool writeExtFlashImgPages(NVS_Handle handle, size_t bytesWritten, MutableByteSpan block) +{ + int_fast16_t status; + NVS_Attrs regionAttrs; + unsigned int erasedSectors; + unsigned int neededSectors; + size_t sectorSize; + + NVS_getAttrs(handle, ®ionAttrs); + sectorSize = regionAttrs.sectorSize; + erasedSectors = (bytesWritten + (sectorSize - 1)) / sectorSize; + neededSectors = ((bytesWritten + block.size()) + (sectorSize - 1)) / sectorSize; + if (neededSectors != erasedSectors) + { + status = NVS_erase(handle, IMG_START + (erasedSectors * sectorSize), (neededSectors - erasedSectors) * sectorSize); + if (status != NVS_STATUS_SUCCESS) + { + return false; + } + } + status = NVS_write(handle, IMG_START + bytesWritten, block.data(), block.size(), NVS_WRITE_POST_VERIFY); + return (status == NVS_STATUS_SUCCESS); +} + +static bool readExtFlashMetaHeader(NVS_Handle handle, ExtImageInfo_t * header) +{ + int_fast16_t status; + status = NVS_read(handle, EFL_ADDR_META, header, sizeof(header)); + return (status == NVS_STATUS_SUCCESS); +} + +static bool eraseExtFlashMetaHeader(NVS_Handle handle) +{ + int_fast16_t status; + NVS_Attrs regionAttrs; + unsigned int sectors; + + NVS_getAttrs(handle, ®ionAttrs); + /* calculate the number of sectors to erase */ + sectors = (sizeof(ExtImageInfo_t) + (regionAttrs.sectorSize - 1)) / regionAttrs.sectorSize; + status = NVS_erase(handle, EFL_ADDR_META, sectors * regionAttrs.sectorSize); + + return (status == NVS_STATUS_SUCCESS); +} + +static bool writeExtFlashMetaHeader(NVS_Handle handle, ExtImageInfo_t * header) +{ + int_fast16_t status; + if (!eraseExtFlashMetaHeader(handle)) + { + return false; + } + status = NVS_write(handle, EFL_ADDR_META, header, sizeof(header), NVS_WRITE_POST_VERIFY); + return (status == NVS_STATUS_SUCCESS); +} + +/** + * Generated on by pycrc v0.9.2, https://pycrc.org using the configuration: + * - Width = 32 + * - Poly = 0x04c11db7 + * - XorIn = 0xffffffff + * - ReflectIn = True + * - XorOut = 0xffffffff + * - ReflectOut = True + * - Algorithm = bit-by-bit-fast + * + * Modified to take uint32_t as the CRC type + */ +uint32_t crc_reflect(uint32_t data, size_t data_len) +{ + unsigned int i; + uint32_t ret; + + ret = data & 0x01; + for (i = 1; i < data_len; i++) + { + data >>= 1; + ret = (ret << 1) | (data & 0x01); + } + return ret; +} + +uint32_t crc_update(uint32_t crc, const void * data, size_t data_len) +{ + const unsigned char * d = (const unsigned char *) data; + unsigned int i; + bool bit; + unsigned char c; + + while (data_len--) + { + c = *d++; + for (i = 0x01; i & 0xff; i <<= 1) + { + bit = crc & 0x80000000; + if (c & i) + { + bit = !bit; + } + crc <<= 1; + if (bit) + { + crc ^= 0x04c11db7; + } + } + crc &= 0xffffffff; + } + return crc & 0xffffffff; +} + +static bool validateExtFlashImage(NVS_Handle handle) +{ + uint32_t crc; + imgFixedHdr_t header; + size_t addr, endAddr; + + if (!readExtFlashImgHeader(handle, &header)) + { + return false; + } + + /* CRC is calculated after the CRC element of the image header */ + addr = IMG_START + IMG_DATA_OFFSET; + endAddr = IMG_START + header.len; + + crc = 0xFFFFFFFF; + + while (addr < endAddr) + { + uint8_t buffer[32]; + size_t bytesLeft = endAddr - addr; + size_t toRead = (sizeof(buffer) < bytesLeft) ? sizeof(buffer) : bytesLeft; + + if (NVS_STATUS_SUCCESS != NVS_read(handle, addr, buffer, toRead)) + { + return false; + } + + crc = crc_update(crc, buffer, toRead); + + addr += toRead; + } + + crc = crc_reflect(crc, 32) ^ 0xffffffff; + + return (crc == header.crc32); +} + +void OTAImageProcessorImpl::HandlePrepareDownload(intptr_t context) +{ + NVS_Params nvsParams; + NVS_Handle handle; + auto * imageProcessor = reinterpret_cast(context); + if (imageProcessor == nullptr) + { + ChipLogError(SoftwareUpdate, "ImageProcessor context is null"); + return; + } + else if (imageProcessor->mDownloader == nullptr) + { + ChipLogError(SoftwareUpdate, "mDownloader is null"); + return; + } + + NVS_Params_init(&nvsParams); + handle = NVS_open(CONFIG_NVSEXTERNAL, &nvsParams); + if (NULL == handle) + { + imageProcessor->mDownloader->OnPreparedForDownload(CHIP_ERROR_OPEN_FAILED); + return; + } + + if (!eraseExtFlashMetaHeader(handle)) + { + NVS_close(handle); + imageProcessor->mDownloader->OnPreparedForDownload(CHIP_ERROR_WRITE_FAILED); + return; + } + + imageProcessor->mNvsHandle = handle; + imageProcessor->mDownloader->OnPreparedForDownload(CHIP_NO_ERROR); +} + +void OTAImageProcessorImpl::HandleFinalize(intptr_t context) +{ + ExtImageInfo_t header; + auto * imageProcessor = reinterpret_cast(context); + if (imageProcessor == nullptr) + { + return; + } + + if (!readExtFlashImgHeader(imageProcessor->mNvsHandle, &(header.fixedHdr))) + { + return; + } + header.extFlAddr = IMG_START; + header.counter = 0x0; + + if (validateExtFlashImage(imageProcessor->mNvsHandle)) + { + // only write the meta header if the crc check passes + writeExtFlashMetaHeader(imageProcessor->mNvsHandle, &header); + } + else + { + // ensure the external image is not mistaken for a valid image + eraseExtFlashMetaHeader(imageProcessor->mNvsHandle); + } + + imageProcessor->ReleaseBlock(); + + ChipLogProgress(SoftwareUpdate, "OTA image downloaded"); +} + +void OTAImageProcessorImpl::HandleApply(intptr_t context) +{ + ExtImageInfo_t header; + auto * imageProcessor = reinterpret_cast(context); + if (imageProcessor == nullptr) + { + return; + } + + if (!readExtFlashMetaHeader(imageProcessor->mNvsHandle, &header)) + { + return; + } + header.fixedHdr.imgCpStat = NEED_COPY; + + writeExtFlashMetaHeader(imageProcessor->mNvsHandle, &header); + + // reset SoC to kick BIM + SysCtrlSystemReset(); +} + +void OTAImageProcessorImpl::HandleAbort(intptr_t context) +{ + auto * imageProcessor = reinterpret_cast(context); + if (imageProcessor == nullptr) + { + return; + } + + if (!eraseExtFlashMetaHeader(imageProcessor->mNvsHandle)) + { + imageProcessor->mDownloader->OnPreparedForDownload(CHIP_ERROR_WRITE_FAILED); + } + + NVS_close(imageProcessor->mNvsHandle); + imageProcessor->ReleaseBlock(); +} + +void OTAImageProcessorImpl::HandleProcessBlock(intptr_t context) +{ + auto * imageProcessor = reinterpret_cast(context); + if (imageProcessor == nullptr) + { + ChipLogError(SoftwareUpdate, "ImageProcessor context is null"); + return; + } + else if (imageProcessor->mDownloader == nullptr) + { + ChipLogError(SoftwareUpdate, "mDownloader is null"); + return; + } + + // TODO: Process block header if any + + if (!writeExtFlashImgPages(imageProcessor->mNvsHandle, imageProcessor->mParams.downloadedBytes, imageProcessor->mBlock)) + { + imageProcessor->mDownloader->EndDownload(CHIP_ERROR_WRITE_FAILED); + return; + } + + imageProcessor->mParams.downloadedBytes += imageProcessor->mBlock.size(); + imageProcessor->mDownloader->FetchNextData(); +} + +CHIP_ERROR OTAImageProcessorImpl::SetBlock(ByteSpan & block) +{ + if ((block.data() == nullptr) || block.empty()) + { + return CHIP_NO_ERROR; + } + + // Allocate memory for block data if it has not been done yet + if (mBlock.empty()) + { + mBlock = MutableByteSpan(static_cast(chip::Platform::MemoryAlloc(block.size())), block.size()); + if (mBlock.data() == nullptr) + { + return CHIP_ERROR_NO_MEMORY; + } + } + + // Store the actual block data + CHIP_ERROR err = CopySpanToMutableSpan(block, mBlock); + if (err != CHIP_NO_ERROR) + { + ChipLogError(SoftwareUpdate, "Cannot copy block data: %" CHIP_ERROR_FORMAT, err.Format()); + return err; + } + + return CHIP_NO_ERROR; +} + +CHIP_ERROR OTAImageProcessorImpl::ReleaseBlock() +{ + if (mBlock.data() != nullptr) + { + chip::Platform::MemoryFree(mBlock.data()); + } + + mBlock = MutableByteSpan(); + return CHIP_NO_ERROR; +} + +} // namespace chip diff --git a/src/platform/cc13x2_26x2/OTAImageProcessorImpl.h b/src/platform/cc13x2_26x2/OTAImageProcessorImpl.h new file mode 100644 index 00000000000000..4caf76b5d744e0 --- /dev/null +++ b/src/platform/cc13x2_26x2/OTAImageProcessorImpl.h @@ -0,0 +1,66 @@ +/* + * + * Copyright (c) 2021 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include +#include + +#include + +namespace chip { + +class OTAImageProcessorImpl : public OTAImageProcessorInterface +{ +public: + //////////// OTAImageProcessorInterface Implementation /////////////// + CHIP_ERROR PrepareDownload() override; + CHIP_ERROR Finalize() override; + CHIP_ERROR Apply() override; + CHIP_ERROR Abort() override; + CHIP_ERROR ProcessBlock(ByteSpan & block) override; + + void SetOTADownloader(OTADownloader * downloader) { mDownloader = downloader; } + +private: + //////////// Actual handlers for the OTAImageProcessorInterface /////////////// + static void HandlePrepareDownload(intptr_t context); + static void HandleFinalize(intptr_t context); + static void HandleApply(intptr_t context); + static void HandleAbort(intptr_t context); + static void HandleProcessBlock(intptr_t context); + + /** + * Called to allocate memory for mBlock if necessary and set it to block + */ + CHIP_ERROR SetBlock(ByteSpan & block); + + /** + * Called to release allocated memory for mBlock + */ + CHIP_ERROR ReleaseBlock(); + + NVS_Handle mNvsHandle; + uint16_t mMetaPage; + MutableByteSpan mBlock; + // can't this be gotten through the requestor? + OTADownloader * mDownloader; +}; + +} // namespace chip diff --git a/src/platform/cc13x2_26x2/cc13x2x7_cc26x2x7_freertos_ota.lds b/src/platform/cc13x2_26x2/cc13x2x7_cc26x2x7_freertos_ota.lds new file mode 100644 index 00000000000000..d470eea96a1888 --- /dev/null +++ b/src/platform/cc13x2_26x2/cc13x2x7_cc26x2x7_freertos_ota.lds @@ -0,0 +1,282 @@ +/* + * + * Copyright (c) 2022 Project CHIP Authors + * Copyright (c) 2020 Texas Instruments Incorporated + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file + * Linkerscript for Matter executable with space reserved for the TI BIM. + */ + +STACKSIZE = 0x800; + +MEMORY +{ + /* last page removed for BIM, CCFG is supplied by that project */ + /* FLASH (RX) : ORIGIN = 0x00000000, LENGTH = 0x000affa8 */ + /* FLASH_CCFG (RX) : ORIGIN = 0x000affa8, LENGTH = 0x00000058 */ + FLASH (RX) : ORIGIN = 0x00000000, LENGTH = 0x000ae000 + /* BLE ROM reserves RAM at the beginning of the ram image */ + /* SRAM (RWX) : ORIGIN = 0x20000000, LENGTH = 0x00024000 */ + SRAM (RWX) : ORIGIN = 0x20000fdf, LENGTH = 0x00023021 + GPRAM (RWX) : ORIGIN = 0x11000000, LENGTH = 0x00002000 + /* Explicitly placed off target for the storage of logging data. + * The data placed here is NOT loaded onto the target device. + * This is part of 1 GB of external memory from 0x60000000 - 0x9FFFFFFF. + * ARM memory map can be found here: + * https://developer.arm.com/documentation/ddi0337/e/memory-map/about-the-memory-map + */ + LOG_DATA (R) : ORIGIN = 0x90000000, LENGTH = 0x40000 +} + +REGION_ALIAS("REGION_TEXT", FLASH); +REGION_ALIAS("REGION_BSS", SRAM); +REGION_ALIAS("REGION_DATA", SRAM); +REGION_ALIAS("REGION_STACK", SRAM); +REGION_ALIAS("REGION_HEAP", SRAM); +REGION_ALIAS("REGION_LOG", LOG_DATA); +REGION_ALIAS("REGION_ARM_EXIDX", FLASH); +REGION_ALIAS("REGION_ARM_EXTAB", FLASH); + +SECTIONS { + /* BIM header placed at the base of flash by default */ + PROVIDE (_img_header_base_address = + DEFINED(_img_header_base_address) ? _img_header_base_address : 0x0); + + .oad_image_header (_img_header_base_address) : AT (_img_header_base_address) { + KEEP (*(.oad_image_header)) + } > REGION_TEXT + + /* interrupt vectors shifted to accomodate BIM header */ + PROVIDE (_intvecs_base_address = + DEFINED(_intvecs_base_address) ? _intvecs_base_address : 0x100); + + .resetVecs (_intvecs_base_address) : AT (_intvecs_base_address) { + KEEP (*(.resetVecs)) + } > REGION_TEXT + + PROVIDE (_vtable_base_address = + DEFINED(_vtable_base_address) ? _vtable_base_address : 0x20000000); + + .vtable (_vtable_base_address) (NOLOAD) : { + KEEP (*(.ramVecs)) + } > REGION_DATA + + /* + * UDMACC26XX_CONFIG_BASE below must match UDMACC26XX_CONFIG_BASE defined + * by ti/drivers/dma/UDMACC26XX.h + * The user is allowed to change UDMACC26XX_CONFIG_BASE to move it away from + * the default address 0x2000_1800, but remember it must be 1024 bytes aligned. + */ + UDMACC26XX_CONFIG_BASE = 0x20001800; + + /* + * Define absolute addresses for the DMA channels. + * DMA channels must always be allocated at a fixed offset from the DMA base address. + * --------- DO NOT MODIFY ----------- + */ + DMA_UART0_RX_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x10); + DMA_UART0_TX_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x20); + DMA_SPI0_RX_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x30); + DMA_SPI0_TX_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x40); + DMA_UART1_RX_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x50); + DMA_UART1_TX_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x60); + DMA_ADC_PRI_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x70); + DMA_GPT0A_PRI_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x90); + DMA_SPI1_RX_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x100); + DMA_SPI1_TX_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x110); + + DMA_UART0_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x210); + DMA_UART0_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x220); + DMA_SPI0_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x230); + DMA_SPI0_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x240); + DMA_UART1_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x250); + DMA_UART1_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x260); + DMA_ADC_ALT_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x270); + DMA_GPT0A_ALT_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x290); + DMA_SPI1_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x300); + DMA_SPI1_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS = (UDMACC26XX_CONFIG_BASE + 0x310); + + /* + * Allocate UART0, UART1, SPI0, SPI1, ADC, and GPTimer0 DMA descriptors at absolute addresses. + * --------- DO NOT MODIFY ----------- + */ + UDMACC26XX_uart0RxControlTableEntry_is_placed = 0; + .dmaUart0RxControlTableEntry DMA_UART0_RX_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_UART0_RX_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaUart0RxControlTableEntry)} > REGION_DATA + + UDMACC26XX_uart0TxControlTableEntry_is_placed = 0; + .dmaUart0TxControlTableEntry DMA_UART0_TX_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_UART0_TX_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaUart0TxControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaSpi0RxControlTableEntry_is_placed = 0; + .dmaSpi0RxControlTableEntry DMA_SPI0_RX_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_SPI0_RX_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaSpi0RxControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaSpi0TxControlTableEntry_is_placed = 0; + .dmaSpi0TxControlTableEntry DMA_SPI0_TX_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_SPI0_TX_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaSpi0TxControlTableEntry)} > REGION_DATA + + UDMACC26XX_uart1RxControlTableEntry_is_placed = 0; + .dmaUart1RxControlTableEntry DMA_UART1_RX_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_UART1_RX_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaUart1RxControlTableEntry)} > REGION_DATA + + UDMACC26XX_uart1TxControlTableEntry_is_placed = 0; + .dmaUart1TxControlTableEntry DMA_UART1_TX_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_UART1_TX_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaUart1TxControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaADCPriControlTableEntry_is_placed = 0; + .dmaADCPriControlTableEntry DMA_ADC_PRI_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_ADC_PRI_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaADCPriControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaGPT0APriControlTableEntry_is_placed = 0; + .dmaGPT0APriControlTableEntry DMA_GPT0A_PRI_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_GPT0A_PRI_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaGPT0APriControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaSpi1RxControlTableEntry_is_placed = 0; + .dmaSpi1RxControlTableEntry DMA_SPI1_RX_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_SPI1_RX_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaSpi1RxControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaSpi1TxControlTableEntry_is_placed = 0; + .dmaSpi1TxControlTableEntry DMA_SPI1_TX_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_SPI1_TX_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaSpi1TxControlTableEntry)} > REGION_DATA + + UDMACC26XX_uart0RxAltControlTableEntry_is_placed = 0; + .dmaUart0RxAltControlTableEntry DMA_UART0_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_UART0_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaUart0RxAltControlTableEntry)} > REGION_DATA + + UDMACC26XX_uart0TxAltControlTableEntry_is_placed = 0; + .dmaUart0TxAltControlTableEntry DMA_UART0_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_UART0_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaUart0TxAltControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaSpi0RxAltControlTableEntry_is_placed = 0; + .dmaSpi0RxAltControlTableEntry DMA_SPI0_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_SPI0_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaSpi0RxAltControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaSpi0TxAltControlTableEntry_is_placed = 0; + .dmaSpi0TxAltControlTableEntry DMA_SPI0_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_SPI0_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaSpi0TxAltControlTableEntry)} > REGION_DATA + + UDMACC26XX_uart1RxAltControlTableEntry_is_placed = 0; + .dmaUart1RxAltControlTableEntry DMA_UART1_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_UART1_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaUart1RxAltControlTableEntry)} > REGION_DATA + + UDMACC26XX_uart1TxAltControlTableEntry_is_placed = 0; + .dmaUart1TxAltControlTableEntry DMA_UART1_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_UART1_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaUart1TxAltControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaADCAltControlTableEntry_is_placed = 0; + .dmaADCAltControlTableEntry DMA_ADC_ALT_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_ADC_ALT_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaADCAltControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaGPT0AAltControlTableEntry_is_placed = 0; + .dmaGPT0AAltControlTableEntry DMA_GPT0A_ALT_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_GPT0A_ALT_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaGPT0AAltControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaSpi1RxAltControlTableEntry_is_placed = 0; + .dmaSpi1RxAltControlTableEntry DMA_SPI1_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_SPI1_RX_ALT_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaSpi1RxAltControlTableEntry)} > REGION_DATA + + UDMACC26XX_dmaSpi1TxAltControlTableEntry_is_placed = 0; + .dmaSpi1TxAltControlTableEntry DMA_SPI1_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS (NOLOAD) : AT (DMA_SPI1_TX_ALT_CONTROL_TABLE_ENTRY_ADDRESS) {*(.dmaSpi1TxAltControlTableEntry)} > REGION_DATA + + + + /* if a ROM-only symbol is present, then ROM is being used. + * Reserve memory for surgically placed config constants. + */ + _rom_rodata_start = 0x2000; + _rom_rodata_size = DEFINED(ROM_RODATA_SIZE) ? 0 : DEFINED(ROM_RODATA_SIZE_NO_OAD) ? 0x330 : 0; + + .rom_rodata_reserve (_rom_rodata_start): { + . += _rom_rodata_size; + } > REGION_TEXT AT> REGION_TEXT + + .text : { + CREATE_OBJECT_SYMBOLS + *(.text) + *(.text.*) + . = ALIGN(0x4); + KEEP (*(.ctors)) + . = ALIGN(0x4); + KEEP (*(.dtors)) + . = ALIGN(0x4); + __init_array_start = .; + KEEP (*(.init_array*)) + __init_array_end = .; + *(.init) + *(.fini*) + } > REGION_TEXT AT> REGION_TEXT + + PROVIDE (__etext = .); + PROVIDE (_etext = .); + PROVIDE (etext = .); + + .rodata : { + *(.rodata) + *(.rodata.*) + *(.rodata_*) + } > REGION_TEXT AT> REGION_TEXT + + .data : ALIGN(4) { + __data_load__ = LOADADDR (.data); + __data_start__ = .; + *(.data) + *(.data.*) + . = ALIGN (4); + __data_end__ = .; + } > REGION_DATA AT> REGION_TEXT + + .ARM.exidx : { + __exidx_start = .; + *(.ARM.exidx* .gnu.linkonce.armexidx.*) + __exidx_end = .; + } > REGION_ARM_EXIDX AT> REGION_ARM_EXIDX + + .ARM.extab : { + *(.ARM.extab* .gnu.linkonce.armextab.*) + } > REGION_ARM_EXTAB AT> REGION_ARM_EXTAB + + /* End of executable code/data, NVS is not part of the OTA image */ + PROVIDE (_flash_end_address = .); + + .nvs (0xAA000) (NOLOAD) : AT (0xAA000) ALIGN(0x2000) { + *(.nvs) + } > REGION_TEXT + + /* CCFG is supplied by the BIM project */ + /* + .ccfg : { + KEEP (*(.ccfg)) + } > FLASH_CCFG AT> FLASH_CCFG + */ + + .bss : { + __bss_start__ = .; + *(.shbss) + *(.bss) + *(.bss.*) + *(COMMON) + . = ALIGN (4); + __bss_end__ = .; + } > REGION_BSS AT> REGION_BSS + + .heap : { + __heap_start__ = .; + end = __heap_start__; + _end = end; + __end = end; + KEEP(*(.heap)) + __heap_end__ = .; + __HeapLimit = __heap_end__; + } > REGION_HEAP AT> REGION_HEAP + + .stack (NOLOAD) : ALIGN(0x8) { + _stack = .; + __stack = .; + KEEP(*(.stack)) + . += STACKSIZE; + _stack_end = .; + __stack_end = .; + } > REGION_STACK AT> REGION_STACK + + .log_data (COPY) : { + KEEP (*(.log_data)) + } > REGION_LOG +} + +ENTRY(resetISR) diff --git a/src/platform/cc13x2_26x2/oad_image_header.c b/src/platform/cc13x2_26x2/oad_image_header.c new file mode 100644 index 00000000000000..5d925c14cdccc8 --- /dev/null +++ b/src/platform/cc13x2_26x2/oad_image_header.c @@ -0,0 +1,81 @@ +/* + * + * Copyright (c) 2020 Project CHIP Authors + * Copyright (c) 2020 Texas Instruments Incorporated + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* definition needed to ensure the OAD image header has room for the ecdsa sig */ +#define SECURITY +#include + +// clang-format off + +#define MY_APP_SOFTWARE_VER { '0', '0', '0', '1' } + +#if defined(__GNUC__) + +/* provided by the linkerfile */ +extern char _flash_end_address; +extern char _intvecs_base_address; + +#define FLASH_END_ADDRESS ((uint32_t)(&_flash_end_address)) +#define RESET_VECT_ADDRESS ((uint32_t)(&_intvecs_base_address)) + +const imgHdr_t __attribute__((section( ".oad_image_header"))) __attribute__((used)) oad_image_header = +#else + +#error "compiler currently note supported" + +#endif + +{ + .fixedHdr = { + .imgID = OAD_IMG_ID_VAL, // User-defined Image Identification bytes + .crc32 = DEFAULT_CRC, // Image's 32-bit CRC value + .bimVer = BIM_VER, // BIM version + .metaVer = META_VER, // Metadata version + .techType = OAD_WIRELESS_TECH_THREAD, // Wireless protocol type BLE/TI-MAC/ZIGBEE etc. + .imgCpStat = DEFAULT_STATE, // Image copy status + .crcStat = DEFAULT_STATE, // CRC status + .imgType = OAD_IMG_TYPE_APP, // Image Type + .imgNo = 0x0, // Image number of 'image type' + .imgVld = DEFAULT_STATE, // Image validation bytes, used by BIM. + .len = INVALID_LEN, // Image length in bytes. + .prgEntry = RESET_VECT_ADDRESS, // Program entry address + .softVer = MY_APP_SOFTWARE_VER, // Software version of the image + .imgEndAddr = FLASH_END_ADDRESS, // Address of the last byte of a contiguous image + .hdrLen = OAD_IMG_FULL_HDR_LEN, // Total length of the image header + .rfu = 0xFFFF, // Reserved bytes + }, +#if (defined(SECURITY)) + .secInfoSeg = { + .segTypeSecure = IMG_SECURITY_SEG_ID, // Segment type - for Secuirty info payload + .wirelessTech = OAD_WIRELESS_TECH_THREAD, // Wireless technology type + .verifStat = DEFAULT_STATE, // Verification status + .secSegLen = SECURITY_SEG_LEN, // Payload segment length + .secVer = SECURITY_VER, // Security version + .secTimestamp = 0x0, // Security timestamp, filled by python script + .secSignerInfo = {0}, // filled by python script + /* .eccSign, filled by python script */ + }, +#endif + .imgPayload = { + .segTypeImg = IMG_PAYLOAD_SEG_ID, // Segment type - for Contiguous image payload + .wirelessTech = OAD_WIRELESS_TECH_THREAD, // Wireless technology type + .rfu = 0, // Reserved bytes + .imgSegLen = 0, // filled by python script + .startAddr = (uint32_t)(&oad_image_header), // Start address of image on internal flash + }, +}; diff --git a/third_party/ti_simplelink_sdk/run_oad_tool.py b/third_party/ti_simplelink_sdk/run_oad_tool.py new file mode 100644 index 00000000000000..8935044c72e55d --- /dev/null +++ b/third_party/ti_simplelink_sdk/run_oad_tool.py @@ -0,0 +1,56 @@ +# Copyright 2020 Texas Instruments Incorporated + +"""A wrapper to run the oad tool. + +This script provides a basic Python wrapper for GN to call the TI OAD image +tool. This will result in a downloadable binary file. Currently this is only +used for CC13XX_CC26XX devices. + +Run with: + python run_oad_tool.py +""" + +import sys +import subprocess +import json +import intelhex + +# The extension is probably not necessary +if sys.platform.startswith('win'): + proc_call = [sys.argv[1] + '/tools/common/oad/oad_image_tool.exe'] + +else: + proc_call = [sys.argv[1] + '/tools/common/oad/oad_image_tool'] + +root_out_dir = sys.argv[2] +project_name = sys.argv[3] +pem_file = sys.argv[4] +hex_file = root_out_dir + '/' + project_name + '.hex' +oad_bin_file = root_out_dir + '/' + project_name + '.bin' +combined_hex = root_out_dir + '/' + project_name + '-bim.hex' +bim_hex_file = sys.argv[5] + +proc_call += [ + '--verbose', + 'ccs', + root_out_dir, + '7', + '-hex1', hex_file, + '-k', pem_file, + '-o', sys.argv[3] +] + +# run oad_tool to fill in the header +subprocess.call(proc_call) + +# merge binary executable with bim hex file +ota_image = intelhex.IntelHex() +ota_image.fromfile(oad_bin_file, format='bin') + +bim_hex = intelhex.IntelHex() +bim_hex.fromfile(bim_hex_file, format='hex') + +ota_image.merge(bim_hex) + +ota_image.tofile(combined_hex, format='hex') + diff --git a/third_party/ti_simplelink_sdk/ti_simplelink_board.gni b/third_party/ti_simplelink_sdk/ti_simplelink_board.gni index d2b6d9d240e853..49f3e40cad5d0c 100644 --- a/third_party/ti_simplelink_sdk/ti_simplelink_board.gni +++ b/third_party/ti_simplelink_sdk/ti_simplelink_board.gni @@ -38,18 +38,21 @@ if (ti_simplelink_board == "CC1352R1_LAUNCHXL") { # set -DDeviceFamily_CC13X2? ti_simplelink_soc = "cc1352r1f3" + ti_simplelink_bim_name = "cc1352r1lp" } else if (ti_simplelink_board == "CC2652R1_LAUNCHXL") { ti_simplelink_device_family = "cc13x2_26x2" ti_simplelink_soc_family = "cc26x2" # set -DDeviceFamily_CC26X2? ti_simplelink_soc = "cc2652r1f3" + ti_simplelink_bim_name = "cc2652r1lp" } else if (ti_simplelink_board == "LP_CC2652R7") { ti_simplelink_device_family = "cc13x2x7_26x2x7" ti_simplelink_soc_family = "cc26x2" # set -DDeviceFamily_CC26X2? ti_simplelink_soc = "cc2652r1f7" + ti_simplelink_bim_name = "cc2652r7lp" } else { print("Please provide a valid value for TI_SIMPLELINK_BOARD env variable") assert(false, "The board ${ti_simplelink_board} is unsupported as for now.") diff --git a/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni b/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni index 0db5bdb3beb97b..4232ca67b7847a 100644 --- a/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni +++ b/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni @@ -13,11 +13,95 @@ # limitations under the License. import("//build_overrides/build.gni") +import("//build_overrides/chip.gni") +import("//build_overrides/ti_simplelink_sdk.gni") import("${build_root}/toolchain/flashable_executable.gni") +import("${chip_root}/src/platform/device.gni") +import("ti_simplelink_sdk.gni") +import("ti_simplelink_board.gni") template("ti_simplelink_executable") { - flashable_executable(target_name) { + simplelink_target_name = target_name + + if (chip_enable_ota_requestor) { + # Generating the ota binary image + final_target = "${target_name}_ota" + } else { + # The executable is the final target. + final_target = "${simplelink_target_name}.out" + } + output_base_name = get_path_info(invoker.output_name, "name") + + objcopy_image_name = output_base_name + ".hex" + objcopy_image_format = "ihex" + objcopy = "arm-none-eabi-objcopy" + + flashable_executable("${simplelink_target_name}.out") { forward_variables_from(invoker, "*") + + if (ti_simplelink_device_family == "cc13x2x7_26x2x7") { + if (chip_enable_ota_requestor) { + sources += [ + "${chip_root}/src/platform/cc13x2_26x2/oad_image_header.c", + ] + ldscript = "${chip_root}/src/platform/cc13x2_26x2/cc13x2x7_cc26x2x7_freertos_ota.lds" + } + else { + ldscript = "${ti_simplelink_sdk_root}/source/ti/dmm/apps/common/freertos/cc13x2x7_cc26x2x7.lds" + } + + inputs = [ ldscript ] + + ldflags = [ + "-L${ti_simplelink_sdk_root}/source", + rebase_path("${target_gen_dir}/sysconfig/ti_utils_build_linker.cmd.genlibs", + root_build_dir), + "-T" + rebase_path(ldscript, root_build_dir), + ] + } + } + + if (chip_enable_ota_requestor && ti_simplelink_device_family == "cc13x2x7_26x2x7") { + pw_python_action("${target_name}_ota") { + public_deps = [ ":${simplelink_target_name}.out.image" ] + + script = "${ti_simplelink_sdk_build_root}/run_oad_tool.py" + sources = ["${root_out_dir}/${objcopy_image_name}"] + outputs = [ + "${root_out_dir}/${output_base_name}.bin", + "${root_out_dir}/${output_base_name}-bim.hex", + ] + + if (defined(invoker.pem_file)) { + pem_file = invoker.pem_file + } + else { + pem_file = "${ti_simplelink_sdk_root}/tools/common/oad/private.pem" + } + + if (defined(invoker.bim_hex)) { + bim_hex = invoker.bim_hex + } + else { + bim_hex = "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/ble5stack/hexfiles/bim_offchip/Release/${ti_simplelink_bim_name}_bim_offchip.hex" + } + + args = [ + ti_simplelink_sdk_root, + rebase_path(root_out_dir, root_build_dir), + output_base_name, + rebase_path(pem_file, root_build_dir), + rebase_path(bim_hex, root_build_dir), + ] + } + } + + group(simplelink_target_name) { + data_deps = [ ":$final_target" ] + + if (defined(invoker.data_deps)) { + data_deps += invoker.data_deps + } } } diff --git a/zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.cpp b/zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.cpp old mode 100644 new mode 100755 index fbed9690c1f3da..006fc302c5615a --- a/zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.cpp +++ b/zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.cpp @@ -16,3 +16,159 @@ */ // THIS FILE IS GENERATED BY ZAP + +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace ::chip; +using namespace ::chip::app::DataModel; + +namespace { +[[maybe_unused]] constexpr uint16_t kByteSpanSizeLengthInBytes = 2; +} // namespace + +#define CHECK_STATUS_WITH_RETVAL(error, retval) \ + if (CHIP_NO_ERROR != error) \ + { \ + ChipLogError(Zcl, "CHECK_STATUS %s", ErrorStr(error)); \ + if (onFailureCallback != nullptr) \ + { \ + Callback::Callback * cb = \ + Callback::Callback::FromCancelable(onFailureCallback); \ + cb->mCall(cb->mContext, static_cast(EMBER_ZCL_STATUS_INVALID_VALUE)); \ + } \ + return retval; \ + } + +#define CHECK_STATUS(error) CHECK_STATUS_WITH_RETVAL(error, true) +#define CHECK_STATUS_VOID(error) CHECK_STATUS_WITH_RETVAL(error, ) + +#define CHECK_MESSAGE_LENGTH_WITH_RETVAL(value, retval) \ + if (!CanCastTo(value)) \ + { \ + ChipLogError(Zcl, "CHECK_MESSAGE_LENGTH expects a uint16_t value, got: %d", value); \ + if (onFailureCallback != nullptr) \ + { \ + Callback::Callback * cb = \ + Callback::Callback::FromCancelable(onFailureCallback); \ + cb->mCall(cb->mContext, static_cast(EMBER_ZCL_STATUS_INVALID_VALUE)); \ + } \ + return retval; \ + } \ + \ + if (messageLen < value) \ + { \ + ChipLogError(Zcl, "Unexpected response length: %d", messageLen); \ + if (onFailureCallback != nullptr) \ + { \ + Callback::Callback * cb = \ + Callback::Callback::FromCancelable(onFailureCallback); \ + cb->mCall(cb->mContext, static_cast(EMBER_ZCL_STATUS_INVALID_VALUE)); \ + } \ + return retval; \ + } \ + \ + messageLen = static_cast(messageLen - static_cast(value)); + +#define CHECK_MESSAGE_LENGTH(value) CHECK_MESSAGE_LENGTH_WITH_RETVAL(value, true) +#define CHECK_MESSAGE_LENGTH_VOID(value) CHECK_MESSAGE_LENGTH_WITH_RETVAL(value, ) + +#define GET_RESPONSE_CALLBACKS(name) \ + Callback::Cancelable * onSuccessCallback = nullptr; \ + Callback::Cancelable * onFailureCallback = nullptr; \ + NodeId sourceId = emberAfCurrentCommand()->SourceNodeId(); \ + uint8_t sequenceNumber = emberAfCurrentCommand()->seqNum; \ + CHIP_ERROR err = gCallbacks.GetResponseCallback(sourceId, sequenceNumber, &onSuccessCallback, &onFailureCallback); \ + \ + if (CHIP_NO_ERROR != err) \ + { \ + if (onSuccessCallback == nullptr) \ + { \ + ChipLogDetail(Zcl, "%s: Missing success callback", name); \ + } \ + \ + if (onFailureCallback == nullptr) \ + { \ + ChipLogDetail(Zcl, "%s: Missing failure callback", name); \ + } \ + \ + return true; \ + } + +#define GET_CLUSTER_RESPONSE_CALLBACKS(name) \ + Callback::Cancelable * onSuccessCallback = nullptr; \ + Callback::Cancelable * onFailureCallback = nullptr; \ + NodeId sourceIdentifier = reinterpret_cast(commandObj); \ + /* #6559: Currently, we only have one commands for the IMInvokeCommands and to a device, so the seqNum is always set to 0. */ \ + CHIP_ERROR err = gCallbacks.GetResponseCallback(sourceIdentifier, 0, &onSuccessCallback, &onFailureCallback); \ + \ + if (CHIP_NO_ERROR != err) \ + { \ + if (onSuccessCallback == nullptr) \ + { \ + ChipLogDetail(Zcl, "%s: Missing success callback", name); \ + } \ + \ + if (onFailureCallback == nullptr) \ + { \ + ChipLogDetail(Zcl, "%s: Missing failure callback", name); \ + } \ + \ + return true; \ + } + +// Singleton instance of the callbacks manager +app::CHIPDeviceCallbacksMgr & gCallbacks = app::CHIPDeviceCallbacksMgr::GetInstance(); + +bool emberAfOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback(EndpointId endpoint, app::CommandSender * commandObj, + uint8_t action, uint32_t delayedActionTime) +{ + ChipLogProgress(Zcl, "ApplyUpdateResponse:"); + ChipLogProgress(Zcl, " action: %" PRIu8 "", action); + ChipLogProgress(Zcl, " delayedActionTime: %" PRIu32 "", delayedActionTime); + + GET_CLUSTER_RESPONSE_CALLBACKS("OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback"); + + Callback::Callback * cb = + Callback::Callback::FromCancelable(onSuccessCallback); + cb->mCall(cb->mContext, action, delayedActionTime); + return true; +} + +bool emberAfOtaSoftwareUpdateProviderClusterQueryImageResponseCallback(EndpointId endpoint, app::CommandSender * commandObj, + uint8_t status, uint32_t delayedActionTime, + chip::CharSpan imageURI, uint32_t softwareVersion, + chip::CharSpan softwareVersionString, + chip::ByteSpan updateToken, bool userConsentNeeded, + chip::ByteSpan metadataForRequestor) +{ + ChipLogProgress(Zcl, "QueryImageResponse:"); + ChipLogProgress(Zcl, " status: %" PRIu8 "", status); + ChipLogProgress(Zcl, " delayedActionTime: %" PRIu32 "", delayedActionTime); + ChipLogProgress(Zcl, " imageURI: %.*s", static_cast(imageURI.size()), imageURI.data()); + ChipLogProgress(Zcl, " softwareVersion: %" PRIu32 "", softwareVersion); + ChipLogProgress(Zcl, " softwareVersionString: %.*s", static_cast(softwareVersionString.size()), + softwareVersionString.data()); + ChipLogProgress(Zcl, " updateToken: %zu", updateToken.size()); + ChipLogProgress(Zcl, " userConsentNeeded: %d", userConsentNeeded); + ChipLogProgress(Zcl, " metadataForRequestor: %zu", metadataForRequestor.size()); + + GET_CLUSTER_RESPONSE_CALLBACKS("OtaSoftwareUpdateProviderClusterQueryImageResponseCallback"); + + Callback::Callback * cb = + Callback::Callback::FromCancelable(onSuccessCallback); + cb->mCall(cb->mContext, status, delayedActionTime, imageURI, softwareVersion, softwareVersionString, updateToken, + userConsentNeeded, metadataForRequestor); + return true; +} diff --git a/zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.h b/zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.h old mode 100644 new mode 100755 index 4ad6af42ab6e54..d1357004d3de3a --- a/zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.h +++ b/zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.h @@ -17,4 +17,28 @@ // THIS FILE IS GENERATED BY ZAP +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Note: The IMDefaultResponseCallback is a bridge to the old CallbackMgr before IM is landed, so it still accepts EmberAfStatus +// instead of IM status code. +// #6308 should handle IM error code on the application side, either modify this function or remove this. + +// Cluster Specific Response Callbacks +typedef void (*OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback)(void * context, uint8_t action, + uint32_t delayedActionTime); +typedef void (*OtaSoftwareUpdateProviderClusterQueryImageResponseCallback)( + void * context, uint8_t status, uint32_t delayedActionTime, chip::CharSpan imageURI, uint32_t softwareVersion, + chip::CharSpan softwareVersionString, chip::ByteSpan updateToken, bool userConsentNeeded, chip::ByteSpan metadataForRequestor); + // List specific responses diff --git a/zzz_generated/lock-app/zap-generated/CHIPClusters.cpp b/zzz_generated/lock-app/zap-generated/CHIPClusters.cpp old mode 100644 new mode 100755 index fbed9690c1f3da..8ba83874fa6545 --- a/zzz_generated/lock-app/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/lock-app/zap-generated/CHIPClusters.cpp @@ -16,3 +16,173 @@ */ // THIS FILE IS GENERATED BY ZAP + +#include "CHIPClusters.h" + +#include +#include + +namespace chip { + +using namespace app::Clusters; +using namespace System; +using namespace Encoding::LittleEndian; + +namespace Controller { + +// TODO(#4502): onCompletion is not used by IM for now. +// TODO(#4503): length should be passed to commands when byte string is in argument list. +// TODO(#4503): Commands should take group id as an argument. + +// OtaSoftwareUpdateProvider Cluster Commands +CHIP_ERROR OtaSoftwareUpdateProviderCluster::ApplyUpdateRequest(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, + chip::ByteSpan updateToken, uint32_t newVersion) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; + + // Used when encoding non-empty command. Suppress error message when encoding empty commands. + (void) writer; + (void) argSeqNumber; + + VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Id, + (app::CommandPathFlags::kEndpointIdValid) }; + + CommandSenderHandle sender( + Platform::New(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->PrepareCommand(cmdParams)); + + VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); + // updateToken: octetString + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), updateToken)); + // newVersion: int32u + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), newVersion)); + + SuccessOrExit(err = sender->FinishCommand()); + + // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); + + SuccessOrExit(err = mDevice->SendCommands(sender.get(), mTimeout)); + + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); +exit: + return err; +} + +CHIP_ERROR OtaSoftwareUpdateProviderCluster::NotifyUpdateApplied(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, + chip::ByteSpan updateToken, uint32_t softwareVersion) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; + + // Used when encoding non-empty command. Suppress error message when encoding empty commands. + (void) writer; + (void) argSeqNumber; + + VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Id, + (app::CommandPathFlags::kEndpointIdValid) }; + + CommandSenderHandle sender( + Platform::New(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->PrepareCommand(cmdParams)); + + VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); + // updateToken: octetString + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), updateToken)); + // softwareVersion: int32u + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), softwareVersion)); + + SuccessOrExit(err = sender->FinishCommand()); + + // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); + + SuccessOrExit(err = mDevice->SendCommands(sender.get(), mTimeout)); + + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); +exit: + return err; +} + +CHIP_ERROR OtaSoftwareUpdateProviderCluster::QueryImage(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, chip::VendorId vendorId, + uint16_t productId, uint32_t softwareVersion, uint8_t protocolsSupported, + uint16_t hardwareVersion, chip::CharSpan location, bool requestorCanConsent, + chip::ByteSpan metadataForProvider) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; + + // Used when encoding non-empty command. Suppress error message when encoding empty commands. + (void) writer; + (void) argSeqNumber; + + VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + OtaSoftwareUpdateProvider::Commands::QueryImage::Id, + (app::CommandPathFlags::kEndpointIdValid) }; + + CommandSenderHandle sender( + Platform::New(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->PrepareCommand(cmdParams)); + + VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); + // vendorId: vendorId + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), vendorId)); + // productId: int16u + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), productId)); + // softwareVersion: int32u + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), softwareVersion)); + // protocolsSupported: OTADownloadProtocol + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), protocolsSupported)); + // hardwareVersion: int16u + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), hardwareVersion)); + // location: charString + SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), location)); + // requestorCanConsent: boolean + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), requestorCanConsent)); + // metadataForProvider: octetString + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), metadataForProvider)); + + SuccessOrExit(err = sender->FinishCommand()); + + // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); + + SuccessOrExit(err = mDevice->SendCommands(sender.get(), mTimeout)); + + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); +exit: + return err; +} + +} // namespace Controller +} // namespace chip diff --git a/zzz_generated/lock-app/zap-generated/CHIPClusters.h b/zzz_generated/lock-app/zap-generated/CHIPClusters.h old mode 100644 new mode 100755 index fbed9690c1f3da..ede4e32855fc3a --- a/zzz_generated/lock-app/zap-generated/CHIPClusters.h +++ b/zzz_generated/lock-app/zap-generated/CHIPClusters.h @@ -16,3 +16,36 @@ */ // THIS FILE IS GENERATED BY ZAP + +// Prevent multiple inclusion +#pragma once + +#include +#include + +#include +#include +#include + +namespace chip { +namespace Controller { + +class DLL_EXPORT OtaSoftwareUpdateProviderCluster : public ClusterBase +{ +public: + OtaSoftwareUpdateProviderCluster() : ClusterBase(app::Clusters::OtaSoftwareUpdateProvider::Id) {} + ~OtaSoftwareUpdateProviderCluster() {} + + // Cluster Commands + CHIP_ERROR ApplyUpdateRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::ByteSpan updateToken, uint32_t newVersion); + CHIP_ERROR NotifyUpdateApplied(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::ByteSpan updateToken, uint32_t softwareVersion); + CHIP_ERROR QueryImage(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + chip::VendorId vendorId, uint16_t productId, uint32_t softwareVersion, uint8_t protocolsSupported, + uint16_t hardwareVersion, chip::CharSpan location, bool requestorCanConsent, + chip::ByteSpan metadataForProvider); +}; + +} // namespace Controller +} // namespace chip diff --git a/zzz_generated/lock-app/zap-generated/IMClusterCommandHandler.cpp b/zzz_generated/lock-app/zap-generated/IMClusterCommandHandler.cpp old mode 100644 new mode 100755 index 54e00e2fd1eeec..2726bfd5778dbc --- a/zzz_generated/lock-app/zap-generated/IMClusterCommandHandler.cpp +++ b/zzz_generated/lock-app/zap-generated/IMClusterCommandHandler.cpp @@ -292,6 +292,237 @@ void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandP } // namespace NetworkCommissioning +namespace OtaSoftwareUpdateProvider { + +void DispatchClientCommand(CommandSender * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) +{ + // We are using TLVUnpackError and TLVError here since both of them can be CHIP_END_OF_TLV + // When TLVError is CHIP_END_OF_TLV, it means we have iterated all of the items, which is not a real error. + // Any error value TLVUnpackError means we have received an illegal value. + // The following variables are used for all commands to save code size. + CHIP_ERROR TLVError = CHIP_NO_ERROR; + CHIP_ERROR TLVUnpackError = CHIP_NO_ERROR; + uint32_t validArgumentCount = 0; + uint32_t expectArgumentCount = 0; + uint32_t currentDecodeTagId = 0; + bool wasHandled = false; + { + switch (aCommandPath.mCommandId) + { + case Commands::ApplyUpdateResponse::Id: { + expectArgumentCount = 2; + uint8_t action; + uint32_t delayedActionTime; + bool argExists[2]; + + memset(argExists, 0, sizeof argExists); + + while ((TLVError = aDataTlv.Next()) == CHIP_NO_ERROR) + { + // Since call to aDataTlv.Next() is CHIP_NO_ERROR, the read head always points to an element. + // Skip this element if it is not a ContextTag, not consider it as an error if other values are valid. + if (!TLV::IsContextTag(aDataTlv.GetTag())) + { + continue; + } + currentDecodeTagId = TLV::TagNumFromTag(aDataTlv.GetTag()); + if (currentDecodeTagId < 2) + { + if (argExists[currentDecodeTagId]) + { + ChipLogProgress(Zcl, "Duplicate TLV tag %" PRIx32, TLV::TagNumFromTag(aDataTlv.GetTag())); + TLVUnpackError = CHIP_ERROR_IM_MALFORMED_COMMAND_DATA_ELEMENT; + break; + } + else + { + argExists[currentDecodeTagId] = true; + validArgumentCount++; + } + } + switch (currentDecodeTagId) + { + case 0: + TLVUnpackError = aDataTlv.Get(action); + break; + case 1: + TLVUnpackError = aDataTlv.Get(delayedActionTime); + break; + default: + // Unsupported tag, ignore it. + ChipLogProgress(Zcl, "Unknown TLV tag during processing."); + break; + } + if (CHIP_NO_ERROR != TLVUnpackError) + { + break; + } + } + + if (CHIP_END_OF_TLV == TLVError) + { + // CHIP_END_OF_TLV means we have iterated all items in the structure, which is not a real error. + TLVError = CHIP_NO_ERROR; + } + + if (CHIP_NO_ERROR == TLVError && CHIP_NO_ERROR == TLVUnpackError && 2 == validArgumentCount) + { + wasHandled = emberAfOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback( + aCommandPath.mEndpointId, apCommandObj, action, delayedActionTime); + } + break; + } + case Commands::QueryImageResponse::Id: { + expectArgumentCount = 8; + uint8_t status; + uint32_t delayedActionTime; + chip::CharSpan imageURI; + uint32_t softwareVersion; + chip::CharSpan softwareVersionString; + chip::ByteSpan updateToken; + bool userConsentNeeded; + chip::ByteSpan metadataForRequestor; + bool argExists[8]; + + memset(argExists, 0, sizeof argExists); + + while ((TLVError = aDataTlv.Next()) == CHIP_NO_ERROR) + { + // Since call to aDataTlv.Next() is CHIP_NO_ERROR, the read head always points to an element. + // Skip this element if it is not a ContextTag, not consider it as an error if other values are valid. + if (!TLV::IsContextTag(aDataTlv.GetTag())) + { + continue; + } + currentDecodeTagId = TLV::TagNumFromTag(aDataTlv.GetTag()); + if (currentDecodeTagId < 8) + { + if (argExists[currentDecodeTagId]) + { + ChipLogProgress(Zcl, "Duplicate TLV tag %" PRIx32, TLV::TagNumFromTag(aDataTlv.GetTag())); + TLVUnpackError = CHIP_ERROR_IM_MALFORMED_COMMAND_DATA_ELEMENT; + break; + } + else + { + argExists[currentDecodeTagId] = true; + validArgumentCount++; + } + } + switch (currentDecodeTagId) + { + case 0: + TLVUnpackError = aDataTlv.Get(status); + break; + case 1: + TLVUnpackError = aDataTlv.Get(delayedActionTime); + break; + case 2: + TLVUnpackError = aDataTlv.Get(imageURI); + break; + case 3: + TLVUnpackError = aDataTlv.Get(softwareVersion); + break; + case 4: + TLVUnpackError = aDataTlv.Get(softwareVersionString); + break; + case 5: + TLVUnpackError = aDataTlv.Get(updateToken); + break; + case 6: + TLVUnpackError = aDataTlv.Get(userConsentNeeded); + break; + case 7: + TLVUnpackError = aDataTlv.Get(metadataForRequestor); + break; + default: + // Unsupported tag, ignore it. + ChipLogProgress(Zcl, "Unknown TLV tag during processing."); + break; + } + if (CHIP_NO_ERROR != TLVUnpackError) + { + break; + } + } + + if (CHIP_END_OF_TLV == TLVError) + { + // CHIP_END_OF_TLV means we have iterated all items in the structure, which is not a real error. + TLVError = CHIP_NO_ERROR; + } + + if (CHIP_NO_ERROR == TLVError && CHIP_NO_ERROR == TLVUnpackError && 8 == validArgumentCount) + { + wasHandled = emberAfOtaSoftwareUpdateProviderClusterQueryImageResponseCallback( + aCommandPath.mEndpointId, apCommandObj, status, delayedActionTime, imageURI, softwareVersion, + softwareVersionString, updateToken, userConsentNeeded, metadataForRequestor); + } + break; + } + default: { + return; + } + } + } + + if (CHIP_NO_ERROR != TLVError || CHIP_NO_ERROR != TLVUnpackError || expectArgumentCount != validArgumentCount || !wasHandled) + { + ChipLogProgress(Zcl, + "Failed to dispatch command, %" PRIu32 "/%" PRIu32 " arguments parsed, TLVError=%" CHIP_ERROR_FORMAT + ", UnpackError=%" CHIP_ERROR_FORMAT " (last decoded tag = %" PRIu32, + validArgumentCount, expectArgumentCount, TLVError.Format(), TLVUnpackError.Format(), currentDecodeTagId); + // A command with no arguments would never write currentDecodeTagId. If + // progress logging is also disabled, it would look unused. Silence that + // warning. + UNUSED_VAR(currentDecodeTagId); + } +} + +} // namespace OtaSoftwareUpdateProvider + +namespace OtaSoftwareUpdateRequestor { + +void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) +{ + // We are using TLVUnpackError and TLVError here since both of them can be CHIP_END_OF_TLV + // When TLVError is CHIP_END_OF_TLV, it means we have iterated all of the items, which is not a real error. + // Any error value TLVUnpackError means we have received an illegal value. + // The following variables are used for all commands to save code size. + CHIP_ERROR TLVError = CHIP_NO_ERROR; + bool wasHandled = false; + { + switch (aCommandPath.mCommandId) + { + case Commands::AnnounceOtaProvider::Id: { + Commands::AnnounceOtaProvider::DecodableType commandData; + TLVError = DataModel::Decode(aDataTlv, commandData); + if (TLVError == CHIP_NO_ERROR) + { + wasHandled = + emberAfOtaSoftwareUpdateRequestorClusterAnnounceOtaProviderCallback(apCommandObj, aCommandPath, commandData); + } + break; + } + default: { + // Unrecognized command ID, error status will apply. + apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); + ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, + ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); + return; + } + } + } + + if (CHIP_NO_ERROR != TLVError || !wasHandled) + { + apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); + ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); + } +} + +} // namespace OtaSoftwareUpdateRequestor + namespace OnOff { void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) @@ -488,6 +719,9 @@ void DispatchSingleClusterCommand(const ConcreteCommandPath & aCommandPath, TLV: case Clusters::NetworkCommissioning::Id: Clusters::NetworkCommissioning::DispatchServerCommand(apCommandObj, aCommandPath, aReader); break; + case Clusters::OtaSoftwareUpdateRequestor::Id: + Clusters::OtaSoftwareUpdateRequestor::DispatchServerCommand(apCommandObj, aCommandPath, aReader); + break; case Clusters::OnOff::Id: Clusters::OnOff::DispatchServerCommand(apCommandObj, aCommandPath, aReader); break; @@ -512,6 +746,9 @@ void DispatchSingleClusterResponseCommand(const ConcreteCommandPath & aCommandPa SuccessOrExit(aReader.EnterContainer(dataTlvType)); switch (aCommandPath.mClusterId) { + case Clusters::OtaSoftwareUpdateProvider::Id: + Clusters::OtaSoftwareUpdateProvider::DispatchClientCommand(apCommandObj, aCommandPath, aReader); + break; default: ChipLogError(Zcl, "Unknown cluster " ChipLogFormatMEI, ChipLogValueMEI(aCommandPath.mClusterId)); break; diff --git a/zzz_generated/lock-app/zap-generated/PluginApplicationCallbacks.h b/zzz_generated/lock-app/zap-generated/PluginApplicationCallbacks.h old mode 100644 new mode 100755 index 876949eb9707bc..1d570942b88944 --- a/zzz_generated/lock-app/zap-generated/PluginApplicationCallbacks.h +++ b/zzz_generated/lock-app/zap-generated/PluginApplicationCallbacks.h @@ -32,6 +32,8 @@ MatterGeneralDiagnosticsPluginServerInitCallback(); \ MatterLocalizationConfigurationPluginServerInitCallback(); \ MatterNetworkCommissioningPluginServerInitCallback(); \ + MatterOtaSoftwareUpdateProviderPluginClientInitCallback(); \ + MatterOtaSoftwareUpdateRequestorPluginServerInitCallback(); \ MatterOnOffPluginServerInitCallback(); \ MatterOperationalCredentialsPluginServerInitCallback(); \ MatterPowerSourcePluginServerInitCallback(); \ diff --git a/zzz_generated/lock-app/zap-generated/af-gen-event.h b/zzz_generated/lock-app/zap-generated/af-gen-event.h old mode 100644 new mode 100755 diff --git a/zzz_generated/lock-app/zap-generated/callback-stub.cpp b/zzz_generated/lock-app/zap-generated/callback-stub.cpp old mode 100644 new mode 100755 index 1be36e96b4f292..652f397173d813 --- a/zzz_generated/lock-app/zap-generated/callback-stub.cpp +++ b/zzz_generated/lock-app/zap-generated/callback-stub.cpp @@ -59,6 +59,12 @@ void emberAfClusterInitCallback(EndpointId endpoint, ClusterId clusterId) case ZCL_NETWORK_COMMISSIONING_CLUSTER_ID: emberAfNetworkCommissioningClusterInitCallback(endpoint); break; + case ZCL_OTA_PROVIDER_CLUSTER_ID: + emberAfOtaSoftwareUpdateProviderClusterInitCallback(endpoint); + break; + case ZCL_OTA_REQUESTOR_CLUSTER_ID: + emberAfOtaSoftwareUpdateRequestorClusterInitCallback(endpoint); + break; case ZCL_ON_OFF_CLUSTER_ID: emberAfOnOffClusterInitCallback(endpoint); break; @@ -142,6 +148,16 @@ void __attribute__((weak)) emberAfNetworkCommissioningClusterInitCallback(Endpoi // To prevent warning (void) endpoint; } +void __attribute__((weak)) emberAfOtaSoftwareUpdateProviderClusterInitCallback(EndpointId endpoint) +{ + // To prevent warning + (void) endpoint; +} +void __attribute__((weak)) emberAfOtaSoftwareUpdateRequestorClusterInitCallback(EndpointId endpoint) +{ + // To prevent warning + (void) endpoint; +} void __attribute__((weak)) emberAfOnOffClusterInitCallback(EndpointId endpoint) { // To prevent warning diff --git a/zzz_generated/lock-app/zap-generated/endpoint_config.h b/zzz_generated/lock-app/zap-generated/endpoint_config.h old mode 100644 new mode 100755 index 3b031411186d3b..33a56b88505576 --- a/zzz_generated/lock-app/zap-generated/endpoint_config.h +++ b/zzz_generated/lock-app/zap-generated/endpoint_config.h @@ -628,7 +628,7 @@ #define ZAP_ATTRIBUTE_MASK(mask) ATTRIBUTE_MASK_##mask // This is an array of EmberAfAttributeMetadata structures. -#define GENERATED_ATTRIBUTE_COUNT 198 +#define GENERATED_ATTRIBUTE_COUNT 204 #define GENERATED_ATTRIBUTES \ { \ \ @@ -668,6 +668,17 @@ { 0x00000012, ZAP_TYPE(CHAR_STRING), 33, ZAP_ATTRIBUTE_MASK(SINGLETON), ZAP_EMPTY_DEFAULT() }, /* UniqueID */ \ { 0x0000FFFD, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(SINGLETON), ZAP_SIMPLE_DEFAULT(1) }, /* ClusterRevision */ \ \ + /* Endpoint: 0, Cluster: OTA Software Update Provider (client) */ \ + { 0x0000FFFD, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(CLIENT), ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \ + \ + /* Endpoint: 0, Cluster: OTA Software Update Requestor (server) */ \ + { 0x00000000, ZAP_TYPE(ARRAY), 0, ZAP_ATTRIBUTE_MASK(EXTERNAL_STORAGE) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ + ZAP_EMPTY_DEFAULT() }, /* DefaultOtaProviders */ \ + { 0x00000001, ZAP_TYPE(BOOLEAN), 1, 0, ZAP_SIMPLE_DEFAULT(1) }, /* UpdatePossible */ \ + { 0x00000002, ZAP_TYPE(ENUM8), 1, 0, ZAP_SIMPLE_DEFAULT(0) }, /* UpdateState */ \ + { 0x00000003, ZAP_TYPE(INT8U), 1, ZAP_ATTRIBUTE_MASK(NULLABLE), ZAP_SIMPLE_DEFAULT(0) }, /* UpdateStateProgress */ \ + { 0x0000FFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(1) }, /* ClusterRevision */ \ + \ /* Endpoint: 0, Cluster: Localization Configuration (server) */ \ { 0x00000001, ZAP_TYPE(CHAR_STRING), 36, ZAP_ATTRIBUTE_MASK(TOKENIZE) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ ZAP_LONG_DEFAULTS_INDEX(24) }, /* ActiveLocale */ \ @@ -912,7 +923,7 @@ }; #define ZAP_CLUSTER_MASK(mask) CLUSTER_MASK_##mask -#define GENERATED_CLUSTER_COUNT 21 +#define GENERATED_CLUSTER_COUNT 23 #define GENERATED_CLUSTERS \ { \ { \ @@ -924,71 +935,77 @@ 687, \ ZAP_CLUSTER_MASK(SERVER) | ZAP_CLUSTER_MASK(INIT_FUNCTION), \ chipFuncArrayBasicServer }, /* Endpoint: 0, Cluster: Basic (server) */ \ + { \ + 0x00000029, ZAP_ATTRIBUTE_INDEX(25), 1, 2, ZAP_CLUSTER_MASK(CLIENT), NULL \ + }, /* Endpoint: 0, Cluster: OTA Software Update Provider (client) */ \ + { \ + 0x0000002A, ZAP_ATTRIBUTE_INDEX(26), 5, 5, ZAP_CLUSTER_MASK(SERVER), NULL \ + }, /* Endpoint: 0, Cluster: OTA Software Update Requestor (server) */ \ { 0x0000002B, \ - ZAP_ATTRIBUTE_INDEX(25), \ + ZAP_ATTRIBUTE_INDEX(31), \ 3, \ 38, \ ZAP_CLUSTER_MASK(SERVER) | ZAP_CLUSTER_MASK(INIT_FUNCTION) | ZAP_CLUSTER_MASK(PRE_ATTRIBUTE_CHANGED_FUNCTION), \ chipFuncArrayLocalizationConfigurationServer }, /* Endpoint: 0, Cluster: Localization Configuration (server) */ \ { 0x0000002C, \ - ZAP_ATTRIBUTE_INDEX(28), \ + ZAP_ATTRIBUTE_INDEX(34), \ 4, \ 4, \ ZAP_CLUSTER_MASK(SERVER) | ZAP_CLUSTER_MASK(INIT_FUNCTION) | ZAP_CLUSTER_MASK(PRE_ATTRIBUTE_CHANGED_FUNCTION), \ chipFuncArrayTimeFormatLocalizationServer }, /* Endpoint: 0, Cluster: Time Format Localization (server) */ \ { \ - 0x0000002E, ZAP_ATTRIBUTE_INDEX(32), 2, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x0000002E, ZAP_ATTRIBUTE_INDEX(38), 2, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: Power Source Configuration (server) */ \ { \ - 0x0000002F, ZAP_ATTRIBUTE_INDEX(34), 6, 73, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x0000002F, ZAP_ATTRIBUTE_INDEX(40), 6, 73, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: Power Source (server) */ \ { \ - 0x00000030, ZAP_ATTRIBUTE_INDEX(40), 6, 270, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x00000030, ZAP_ATTRIBUTE_INDEX(46), 6, 270, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: General Commissioning (server) */ \ { \ - 0x00000031, ZAP_ATTRIBUTE_INDEX(46), 10, 60, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x00000031, ZAP_ATTRIBUTE_INDEX(52), 10, 60, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: Network Commissioning (server) */ \ { \ - 0x00000032, ZAP_ATTRIBUTE_INDEX(56), 0, 0, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x00000032, ZAP_ATTRIBUTE_INDEX(62), 0, 0, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: Diagnostic Logs (server) */ \ { \ - 0x00000033, ZAP_ATTRIBUTE_INDEX(56), 9, 17, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x00000033, ZAP_ATTRIBUTE_INDEX(62), 9, 17, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: General Diagnostics (server) */ \ { \ - 0x00000034, ZAP_ATTRIBUTE_INDEX(65), 6, 30, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x00000034, ZAP_ATTRIBUTE_INDEX(71), 6, 30, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: Software Diagnostics (server) */ \ { \ - 0x00000035, ZAP_ATTRIBUTE_INDEX(71), 65, 247, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x00000035, ZAP_ATTRIBUTE_INDEX(77), 65, 247, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: Thread Network Diagnostics (server) */ \ { \ - 0x00000036, ZAP_ATTRIBUTE_INDEX(136), 15, 58, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x00000036, ZAP_ATTRIBUTE_INDEX(142), 15, 58, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: WiFi Network Diagnostics (server) */ \ { \ - 0x00000037, ZAP_ATTRIBUTE_INDEX(151), 11, 57, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x00000037, ZAP_ATTRIBUTE_INDEX(157), 11, 57, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: Ethernet Network Diagnostics (server) */ \ { \ - 0x0000003C, ZAP_ATTRIBUTE_INDEX(162), 4, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x0000003C, ZAP_ATTRIBUTE_INDEX(168), 4, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: AdministratorCommissioning (server) */ \ { \ - 0x0000003E, ZAP_ATTRIBUTE_INDEX(166), 7, 4, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x0000003E, ZAP_ATTRIBUTE_INDEX(172), 7, 4, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: Operational Credentials (server) */ \ { \ - 0x00000040, ZAP_ATTRIBUTE_INDEX(173), 2, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x00000040, ZAP_ATTRIBUTE_INDEX(179), 2, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: Fixed Label (server) */ \ { \ - 0x00000041, ZAP_ATTRIBUTE_INDEX(175), 2, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x00000041, ZAP_ATTRIBUTE_INDEX(181), 2, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 0, Cluster: User Label (server) */ \ { 0x00000006, \ - ZAP_ATTRIBUTE_INDEX(177), \ + ZAP_ATTRIBUTE_INDEX(183), \ 7, \ 13, \ ZAP_CLUSTER_MASK(SERVER) | ZAP_CLUSTER_MASK(INIT_FUNCTION), \ chipFuncArrayOnOffServer }, /* Endpoint: 1, Cluster: On/Off (server) */ \ { \ - 0x0000001D, ZAP_ATTRIBUTE_INDEX(184), 5, 0, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x0000001D, ZAP_ATTRIBUTE_INDEX(190), 5, 0, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 1, Cluster: Descriptor (server) */ \ { \ - 0x0000002F, ZAP_ATTRIBUTE_INDEX(189), 9, 133, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x0000002F, ZAP_ATTRIBUTE_INDEX(195), 9, 133, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 1, Cluster: Power Source (server) */ \ } @@ -997,7 +1014,7 @@ // This is an array of EmberAfEndpointType structures. #define GENERATED_ENDPOINT_TYPES \ { \ - { ZAP_CLUSTER_INDEX(0), 18, 1553 }, { ZAP_CLUSTER_INDEX(18), 3, 146 }, \ + { ZAP_CLUSTER_INDEX(0), 20, 1560 }, { ZAP_CLUSTER_INDEX(20), 3, 146 }, \ } // Largest attribute size is needed for various buffers @@ -1007,7 +1024,7 @@ #define ATTRIBUTE_SINGLETONS_SIZE (687) // Total size of attribute storage -#define ATTRIBUTE_MAX_SIZE (1699) +#define ATTRIBUTE_MAX_SIZE (1706) // Number of fixed endpoints #define FIXED_ENDPOINT_COUNT (2) diff --git a/zzz_generated/lock-app/zap-generated/gen_config.h b/zzz_generated/lock-app/zap-generated/gen_config.h old mode 100644 new mode 100755 index c430564bad832a..148c826138f688 --- a/zzz_generated/lock-app/zap-generated/gen_config.h +++ b/zzz_generated/lock-app/zap-generated/gen_config.h @@ -39,6 +39,8 @@ #define EMBER_AF_GENERAL_DIAGNOSTICS_CLUSTER_SERVER_ENDPOINT_COUNT (1) #define EMBER_AF_LOCALIZATION_CONFIGURATION_CLUSTER_SERVER_ENDPOINT_COUNT (1) #define EMBER_AF_NETWORK_COMMISSIONING_CLUSTER_SERVER_ENDPOINT_COUNT (1) +#define EMBER_AF_OTA_PROVIDER_CLUSTER_CLIENT_ENDPOINT_COUNT (1) +#define EMBER_AF_OTA_REQUESTOR_CLUSTER_SERVER_ENDPOINT_COUNT (1) #define EMBER_AF_ON_OFF_CLUSTER_SERVER_ENDPOINT_COUNT (1) #define EMBER_AF_OPERATIONAL_CREDENTIALS_CLUSTER_SERVER_ENDPOINT_COUNT (1) #define EMBER_AF_POWER_SOURCE_CLUSTER_SERVER_ENDPOINT_COUNT (2) @@ -101,6 +103,15 @@ #define EMBER_AF_PLUGIN_NETWORK_COMMISSIONING_SERVER #define EMBER_AF_PLUGIN_NETWORK_COMMISSIONING +// Use this macro to check if the client side of the OTA Software Update Provider cluster is included +#define ZCL_USING_OTA_PROVIDER_CLUSTER_CLIENT +#define EMBER_AF_PLUGIN_OTA_SOFTWARE_UPDATE_PROVIDER_CLIENT + +// Use this macro to check if the server side of the OTA Software Update Requestor cluster is included +#define ZCL_USING_OTA_REQUESTOR_CLUSTER_SERVER +#define EMBER_AF_PLUGIN_OTA_SOFTWARE_UPDATE_REQUESTOR_SERVER +#define EMBER_AF_PLUGIN_OTA_SOFTWARE_UPDATE_REQUESTOR + // Use this macro to check if the server side of the On/Off cluster is included #define ZCL_USING_ON_OFF_CLUSTER_SERVER #define EMBER_AF_PLUGIN_ON_OFF_SERVER diff --git a/zzz_generated/lock-app/zap-generated/gen_tokens.h b/zzz_generated/lock-app/zap-generated/gen_tokens.h old mode 100644 new mode 100755 From 016447315fa2a33fb8ebea9b023cba600c66359f Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Thu, 27 Jan 2022 19:41:49 +0000 Subject: [PATCH 02/14] Restyled by gn --- .../ti_simplelink_executable.gni | 26 +++++++++---------- 1 file changed, 12 insertions(+), 14 deletions(-) diff --git a/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni b/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni index 4232ca67b7847a..f8a00d79bdf245 100644 --- a/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni +++ b/third_party/ti_simplelink_sdk/ti_simplelink_executable.gni @@ -18,8 +18,8 @@ import("//build_overrides/ti_simplelink_sdk.gni") import("${build_root}/toolchain/flashable_executable.gni") import("${chip_root}/src/platform/device.gni") -import("ti_simplelink_sdk.gni") import("ti_simplelink_board.gni") +import("ti_simplelink_sdk.gni") template("ti_simplelink_executable") { simplelink_target_name = target_name @@ -42,12 +42,10 @@ template("ti_simplelink_executable") { if (ti_simplelink_device_family == "cc13x2x7_26x2x7") { if (chip_enable_ota_requestor) { - sources += [ - "${chip_root}/src/platform/cc13x2_26x2/oad_image_header.c", - ] + sources += + [ "${chip_root}/src/platform/cc13x2_26x2/oad_image_header.c" ] ldscript = "${chip_root}/src/platform/cc13x2_26x2/cc13x2x7_cc26x2x7_freertos_ota.lds" - } - else { + } else { ldscript = "${ti_simplelink_sdk_root}/source/ti/dmm/apps/common/freertos/cc13x2x7_cc26x2x7.lds" } @@ -55,19 +53,21 @@ template("ti_simplelink_executable") { ldflags = [ "-L${ti_simplelink_sdk_root}/source", - rebase_path("${target_gen_dir}/sysconfig/ti_utils_build_linker.cmd.genlibs", - root_build_dir), + rebase_path( + "${target_gen_dir}/sysconfig/ti_utils_build_linker.cmd.genlibs", + root_build_dir), "-T" + rebase_path(ldscript, root_build_dir), ] } } - if (chip_enable_ota_requestor && ti_simplelink_device_family == "cc13x2x7_26x2x7") { + if (chip_enable_ota_requestor && + ti_simplelink_device_family == "cc13x2x7_26x2x7") { pw_python_action("${target_name}_ota") { public_deps = [ ":${simplelink_target_name}.out.image" ] script = "${ti_simplelink_sdk_build_root}/run_oad_tool.py" - sources = ["${root_out_dir}/${objcopy_image_name}"] + sources = [ "${root_out_dir}/${objcopy_image_name}" ] outputs = [ "${root_out_dir}/${output_base_name}.bin", "${root_out_dir}/${output_base_name}-bim.hex", @@ -75,15 +75,13 @@ template("ti_simplelink_executable") { if (defined(invoker.pem_file)) { pem_file = invoker.pem_file - } - else { + } else { pem_file = "${ti_simplelink_sdk_root}/tools/common/oad/private.pem" } if (defined(invoker.bim_hex)) { bim_hex = invoker.bim_hex - } - else { + } else { bim_hex = "${ti_simplelink_sdk_root}/examples/rtos/${ti_simplelink_board}/ble5stack/hexfiles/bim_offchip/Release/${ti_simplelink_bim_name}_bim_offchip.hex" } From 05ff5aab9b9768e4abe27b57f2c65f38d1d8688e Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Thu, 27 Jan 2022 19:41:51 +0000 Subject: [PATCH 03/14] Restyled by autopep8 --- third_party/ti_simplelink_sdk/run_oad_tool.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/third_party/ti_simplelink_sdk/run_oad_tool.py b/third_party/ti_simplelink_sdk/run_oad_tool.py index 8935044c72e55d..9c7b62da4f883d 100644 --- a/third_party/ti_simplelink_sdk/run_oad_tool.py +++ b/third_party/ti_simplelink_sdk/run_oad_tool.py @@ -24,8 +24,8 @@ root_out_dir = sys.argv[2] project_name = sys.argv[3] -pem_file = sys.argv[4] -hex_file = root_out_dir + '/' + project_name + '.hex' +pem_file = sys.argv[4] +hex_file = root_out_dir + '/' + project_name + '.hex' oad_bin_file = root_out_dir + '/' + project_name + '.bin' combined_hex = root_out_dir + '/' + project_name + '-bim.hex' bim_hex_file = sys.argv[5] @@ -53,4 +53,3 @@ ota_image.merge(bim_hex) ota_image.tofile(combined_hex, format='hex') - From 78d4b437b3d5338948c234b4022b2b27050d6089 Mon Sep 17 00:00:00 2001 From: Seth Rickard Date: Thu, 27 Jan 2022 22:27:05 +0000 Subject: [PATCH 04/14] fixup CMake builds --- examples/lock-app/esp32/main/CMakeLists.txt | 3 +++ examples/lock-app/mbed/CMakeLists.txt | 6 +++--- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/examples/lock-app/esp32/main/CMakeLists.txt b/examples/lock-app/esp32/main/CMakeLists.txt index 333c0573deb2f6..eb988288312dd8 100644 --- a/examples/lock-app/esp32/main/CMakeLists.txt +++ b/examples/lock-app/esp32/main/CMakeLists.txt @@ -47,11 +47,13 @@ idf_component_register(INCLUDE_DIRS "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/network-commissioning-old" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/on-off-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/operational-credentials-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/ota-requestor" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/general-commissioning-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/diagnostic-logs-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/ethernet-network-diagnostics-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/thread-network-diagnostics-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/wifi-network-diagnostics-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/ota-requestor" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/software-diagnostics-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/switch-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/general-diagnostics-server" @@ -153,6 +155,7 @@ idf_component_register(PRIV_INCLUDE_DIRS "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/network-commissioning-old" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/on-off-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/operational-credentials-server" + "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/ota-requestor" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/general-commissioning-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/power-source-configuration-server" "${CMAKE_SOURCE_DIR}/third_party/connectedhomeip/src/app/clusters/power-source-server" diff --git a/examples/lock-app/mbed/CMakeLists.txt b/examples/lock-app/mbed/CMakeLists.txt index 6c7508bd619347..f02ef2d07b8de1 100644 --- a/examples/lock-app/mbed/CMakeLists.txt +++ b/examples/lock-app/mbed/CMakeLists.txt @@ -90,9 +90,9 @@ target_sources(${APP_TARGET} PRIVATE ${CHIP_ROOT}/src/app/clusters/general-commissioning-server/general-commissioning-server.cpp ${CHIP_ROOT}/src/app/clusters/network-commissioning-old/network-commissioning-ember.cpp ${CHIP_ROOT}/src/app/clusters/network-commissioning-old/network-commissioning-old.cpp - ${CHIP_ROOT}/src/app/clusters/operational-credentials-server/operational-credentials-server.cpp - ${CHIP_ROOT}/src/app/clusters/on-off-server/on-off-server.cpp - ${CHIP_ROOT}/src/app/clusters/power-source-configuration-server/power-source-configuration-server.cpp + ${CHIP_ROOT}/src/app/clusters/ota-requestor/ota-requestor-server.cpp + ${CHIP_ROOT}/src/app/clusters/ota-requestor/BDXDownloader.cpp + ${CHIP_ROOT}/src/app/clusters/ota-requestor/OTARequestor.cpp ${CHIP_ROOT}/src/app/clusters/power-source-server/power-source-server.cpp ${CHIP_ROOT}/src/app/clusters/user-label-server/user-label-server.cpp ) From 47c8a40393759c2f770e55079590d502fc70c92f Mon Sep 17 00:00:00 2001 From: Seth Rickard Date: Fri, 28 Jan 2022 15:10:28 +0000 Subject: [PATCH 05/14] update setBlock and remove old comment --- .../cc13x2_26x2/OTAImageProcessorImpl.cpp | 19 ++++++++++--------- .../cc13x2_26x2/OTAImageProcessorImpl.h | 1 - 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp b/src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp index ed3705d7663415..7de484f0d30d73 100644 --- a/src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp +++ b/src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp @@ -396,29 +396,30 @@ void OTAImageProcessorImpl::HandleProcessBlock(intptr_t context) CHIP_ERROR OTAImageProcessorImpl::SetBlock(ByteSpan & block) { - if ((block.data() == nullptr) || block.empty()) + if (!IsSpanUsable(block)) { + ReleaseBlock(); return CHIP_NO_ERROR; } - - // Allocate memory for block data if it has not been done yet - if (mBlock.empty()) + if (mBlock.size() < block.size()) { - mBlock = MutableByteSpan(static_cast(chip::Platform::MemoryAlloc(block.size())), block.size()); - if (mBlock.data() == nullptr) + if (!mBlock.empty()) + { + ReleaseBlock(); + } + uint8_t * mBlock_ptr = static_cast(chip::Platform::MemoryAlloc(block.size())); + if (mBlock_ptr == nullptr) { return CHIP_ERROR_NO_MEMORY; } + mBlock = MutableByteSpan(mBlock_ptr, block.size()); } - - // Store the actual block data CHIP_ERROR err = CopySpanToMutableSpan(block, mBlock); if (err != CHIP_NO_ERROR) { ChipLogError(SoftwareUpdate, "Cannot copy block data: %" CHIP_ERROR_FORMAT, err.Format()); return err; } - return CHIP_NO_ERROR; } diff --git a/src/platform/cc13x2_26x2/OTAImageProcessorImpl.h b/src/platform/cc13x2_26x2/OTAImageProcessorImpl.h index 4caf76b5d744e0..8471d753ca3ff6 100644 --- a/src/platform/cc13x2_26x2/OTAImageProcessorImpl.h +++ b/src/platform/cc13x2_26x2/OTAImageProcessorImpl.h @@ -59,7 +59,6 @@ class OTAImageProcessorImpl : public OTAImageProcessorInterface NVS_Handle mNvsHandle; uint16_t mMetaPage; MutableByteSpan mBlock; - // can't this be gotten through the requestor? OTADownloader * mDownloader; }; From c26830ca378c397d4c1a156b07224ac37e9e130a Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Mon, 31 Jan 2022 17:23:00 +0000 Subject: [PATCH 06/14] Restyled by whitespace --- .../chip/devicecontroller/ChipClusters.java | 242 ++-- .../chip/devicecontroller/ChipStructs.java | 2 +- .../devicecontroller/ClusterInfoMapping.java | 1009 ++++++++--------- .../devicecontroller/ClusterReadMapping.java | 1 - .../devicecontroller/ClusterWriteMapping.java | 269 +++-- 5 files changed, 760 insertions(+), 763 deletions(-) diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index bad2cfd7e68797..84244edbcb62c1 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -86,7 +86,7 @@ public BaseChipCluster(long devicePtr, int endpointId) { public abstract long initWithDevice(long devicePtr, int endpointId); public native void deleteCluster(long chipClusterPtr); - + @SuppressWarnings("deprecation") protected void finalize() throws Throwable { super.finalize(); @@ -245,7 +245,7 @@ public void loginRequest(DefaultClusterCallback callback public void logoutRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { logoutRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -256,11 +256,11 @@ private native void loginRequest(long chipClusterPtr, DefaultClusterCallback Cal , String tempAccountIdentifier, String setupPIN , @Nullable Integer timedInvokeTimeoutMs); private native void logoutRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface GetSetupPINResponseCallback { void onSuccess(String setupPIN); - + void onError(Exception error); } @@ -336,7 +336,7 @@ public void openCommissioningWindow(DefaultClusterCallback callback public void revokeCommissioning(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -347,7 +347,7 @@ private native void openCommissioningWindow(long chipClusterPtr, DefaultClusterC , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID , @Nullable Integer timedInvokeTimeoutMs); private native void revokeCommissioning(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AdminFabricIndexAttributeCallback { @@ -703,7 +703,7 @@ private native void stopAppRequest(long chipClusterPtr, LauncherResponseCallback , @Nullable Integer timedInvokeTimeoutMs); public interface LauncherResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } @@ -930,7 +930,7 @@ public void barrierControlStop(DefaultClusterCallback callback } public void barrierControlStop(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { barrierControlStop(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -938,7 +938,7 @@ private native void barrierControlGoToPercent(long chipClusterPtr, DefaultCluste , Integer percentOpen , @Nullable Integer timedInvokeTimeoutMs); private native void barrierControlStop(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -2195,7 +2195,7 @@ private native void skipChannelRequest(long chipClusterPtr, DefaultClusterCallba , @Nullable Integer timedInvokeTimeoutMs); public interface ChangeChannelResponseCallback { void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType); - + void onError(Exception error); } @@ -3734,7 +3734,7 @@ private native void launchURLRequest(long chipClusterPtr, LaunchResponseCallback , @Nullable Integer timedInvokeTimeoutMs); public interface LaunchResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } @@ -4012,7 +4012,7 @@ private native void retrieveLogsRequest(long chipClusterPtr, RetrieveLogsRespons , @Nullable Integer timedInvokeTimeoutMs); public interface RetrieveLogsResponseCallback { void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot); - + void onError(Exception error); } @@ -4236,31 +4236,31 @@ private native void unlockWithTimeout(long chipClusterPtr, DefaultClusterCallbac , @Nullable Integer timedInvokeTimeoutMs); public interface GetCredentialStatusResponseCallback { void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); - + void onError(Exception error); } public interface GetUserResponseCallback { void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex); - + void onError(Exception error); } public interface GetWeekDayScheduleResponseCallback { void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute); - + void onError(Exception error); } public interface GetYearDayScheduleResponseCallback { void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime); - + void onError(Exception error); } public interface SetCredentialResponseCallback { void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); - + void onError(Exception error); } @@ -5062,12 +5062,12 @@ public void resetCounts(DefaultClusterCallback callback } public void resetCounts(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -5542,7 +5542,7 @@ public void commissioningComplete(CommissioningCompleteResponseCallback callback } public void commissioningComplete(CommissioningCompleteResponseCallback callback - + , int timedInvokeTimeoutMs) { commissioningComplete(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -5561,26 +5561,26 @@ private native void armFailSafe(long chipClusterPtr, ArmFailSafeResponseCallback , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs , @Nullable Integer timedInvokeTimeoutMs); private native void commissioningComplete(long chipClusterPtr, CommissioningCompleteResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void setRegulatoryConfig(long chipClusterPtr, SetRegulatoryConfigResponseCallback Callback , Integer location, String countryCode, Long breadcrumb, Long timeoutMs , @Nullable Integer timedInvokeTimeoutMs); public interface ArmFailSafeResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } public interface CommissioningCompleteResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } public interface SetRegulatoryConfigResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } @@ -6014,13 +6014,13 @@ private native void keySetWrite(long chipClusterPtr, DefaultClusterCallback Call , @Nullable Integer timedInvokeTimeoutMs); public interface KeySetReadAllIndicesResponseCallback { void onSuccess(ArrayList groupKeySetIDs); - + void onError(Exception error); } public interface KeySetReadResponseCallback { void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet); - + void onError(Exception error); } @@ -6205,7 +6205,7 @@ public void removeAllGroups(DefaultClusterCallback callback } public void removeAllGroups(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { removeAllGroups(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -6241,7 +6241,7 @@ private native void getGroupMembership(long chipClusterPtr, GetGroupMembershipRe , ArrayList groupList , @Nullable Integer timedInvokeTimeoutMs); private native void removeAllGroups(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void removeGroup(long chipClusterPtr, RemoveGroupResponseCallback Callback , Integer groupId @@ -6251,25 +6251,25 @@ private native void viewGroup(long chipClusterPtr, ViewGroupResponseCallback Cal , @Nullable Integer timedInvokeTimeoutMs); public interface AddGroupResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface GetGroupMembershipResponseCallback { void onSuccess(Integer capacity, ArrayList groupList); - + void onError(Exception error); } public interface RemoveGroupResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface ViewGroupResponseCallback { void onSuccess(Integer status, Integer groupId, String groupName); - + void onError(Exception error); } @@ -6365,7 +6365,7 @@ public void identifyQuery(IdentifyQueryResponseCallback callback } public void identifyQuery(IdentifyQueryResponseCallback callback - + , int timedInvokeTimeoutMs) { identifyQuery(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -6384,14 +6384,14 @@ private native void identify(long chipClusterPtr, DefaultClusterCallback Callbac , Integer identifyTime , @Nullable Integer timedInvokeTimeoutMs); private native void identifyQuery(long chipClusterPtr, IdentifyQueryResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void triggerEffect(long chipClusterPtr, DefaultClusterCallback Callback , Integer effectIdentifier, Integer effectVariant , @Nullable Integer timedInvokeTimeoutMs); public interface IdentifyQueryResponseCallback { void onSuccess(Integer timeout); - + void onError(Exception error); } @@ -6683,7 +6683,7 @@ private native void sendKeyRequest(long chipClusterPtr, SendKeyResponseCallback , @Nullable Integer timedInvokeTimeoutMs); public interface SendKeyResponseCallback { void onSuccess(Integer status); - + void onError(Exception error); } @@ -6826,7 +6826,7 @@ public void stopWithOnOff(DefaultClusterCallback callback } public void stopWithOnOff(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -6852,7 +6852,7 @@ private native void stop(long chipClusterPtr, DefaultClusterCallback Callback , Integer optionMask, Integer optionOverride , @Nullable Integer timedInvokeTimeoutMs); private native void stopWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface OnLevelAttributeCallback { @@ -7372,12 +7372,12 @@ public void sleep(DefaultClusterCallback callback } public void sleep(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { sleep(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void sleep(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -7441,7 +7441,7 @@ public void hideInputStatusRequest(DefaultClusterCallback callback } public void hideInputStatusRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { hideInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7474,12 +7474,12 @@ public void showInputStatusRequest(DefaultClusterCallback callback } public void showInputStatusRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { showInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void hideInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void renameInputRequest(long chipClusterPtr, DefaultClusterCallback Callback , Integer index, String name @@ -7488,7 +7488,7 @@ private native void selectInputRequest(long chipClusterPtr, DefaultClusterCallba , Integer index , @Nullable Integer timedInvokeTimeoutMs); private native void showInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface MediaInputListAttributeCallback { @@ -7595,7 +7595,7 @@ public void fastForwardRequest(PlaybackResponseCallback callback } public void fastForwardRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { fastForwardRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7606,7 +7606,7 @@ public void nextRequest(PlaybackResponseCallback callback } public void nextRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { nextRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7617,7 +7617,7 @@ public void pauseRequest(PlaybackResponseCallback callback } public void pauseRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { pauseRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7628,7 +7628,7 @@ public void playRequest(PlaybackResponseCallback callback } public void playRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { playRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7639,7 +7639,7 @@ public void previousRequest(PlaybackResponseCallback callback } public void previousRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { previousRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7650,7 +7650,7 @@ public void rewindRequest(PlaybackResponseCallback callback } public void rewindRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { rewindRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7694,7 +7694,7 @@ public void startOverRequest(PlaybackResponseCallback callback } public void startOverRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { startOverRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7705,27 +7705,27 @@ public void stopRequest(PlaybackResponseCallback callback } public void stopRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { stopRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void fastForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void nextRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void pauseRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void playRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void previousRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void rewindRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void seekRequest(long chipClusterPtr, PlaybackResponseCallback Callback , Long position @@ -7737,14 +7737,14 @@ private native void skipForwardRequest(long chipClusterPtr, PlaybackResponseCall , Long deltaPositionMilliseconds , @Nullable Integer timedInvokeTimeoutMs); private native void startOverRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void stopRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface PlaybackResponseCallback { void onSuccess(Integer status); - + void onError(Exception error); } @@ -8181,19 +8181,19 @@ private native void scanNetworks(long chipClusterPtr, ScanNetworksResponseCallba , @Nullable Integer timedInvokeTimeoutMs); public interface ConnectNetworkResponseCallback { void onSuccess(Integer networkingStatus, String debugText, Long errorValue); - + void onError(Exception error); } public interface NetworkConfigResponseCallback { void onSuccess(Integer networkingStatus, String debugText); - + void onError(Exception error); } public interface ScanNetworksResponseCallback { void onSuccess(Integer networkingStatus, String debugText, Optional> wiFiScanResults, Optional> threadScanResults); - + void onError(Exception error); } @@ -8457,13 +8457,13 @@ private native void queryImage(long chipClusterPtr, QueryImageResponseCallback C , @Nullable Integer timedInvokeTimeoutMs); public interface ApplyUpdateResponseCallback { void onSuccess(Integer action, Long delayedActionTime); - + void onError(Exception error); } public interface QueryImageResponseCallback { void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor); - + void onError(Exception error); } @@ -8805,7 +8805,7 @@ public void off(DefaultClusterCallback callback } public void off(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { off(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -8827,7 +8827,7 @@ public void on(DefaultClusterCallback callback } public void on(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { on(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -8838,7 +8838,7 @@ public void onWithRecallGlobalScene(DefaultClusterCallback callback } public void onWithRecallGlobalScene(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { onWithRecallGlobalScene(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -8860,27 +8860,27 @@ public void toggle(DefaultClusterCallback callback } public void toggle(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { toggle(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void off(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void offWithEffect(long chipClusterPtr, DefaultClusterCallback Callback , Integer effectId, Integer effectVariant , @Nullable Integer timedInvokeTimeoutMs); private native void on(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void onWithRecallGlobalScene(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void onWithTimedOff(long chipClusterPtr, DefaultClusterCallback Callback , Integer onOffControl, Integer onTime, Integer offWaitTime , @Nullable Integer timedInvokeTimeoutMs); private native void toggle(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -9308,25 +9308,25 @@ private native void updateNOC(long chipClusterPtr, NOCResponseCallback Callback , @Nullable Integer timedInvokeTimeoutMs); public interface AttestationResponseCallback { void onSuccess(byte[] attestationElements, byte[] signature); - + void onError(Exception error); } public interface CertificateChainResponseCallback { void onSuccess(byte[] certificate); - + void onError(Exception error); } public interface NOCResponseCallback { void onSuccess(Integer statusCode, Integer fabricIndex, String debugText); - + void onError(Exception error); } public interface OpCSRResponseCallback { void onSuccess(byte[] NOCSRElements, byte[] attestationSignature); - + void onError(Exception error); } @@ -10767,37 +10767,37 @@ private native void viewScene(long chipClusterPtr, ViewSceneResponseCallback Cal , @Nullable Integer timedInvokeTimeoutMs); public interface AddSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface GetSceneMembershipResponseCallback { void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList); - + void onError(Exception error); } public interface RemoveAllScenesResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface RemoveSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface StoreSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface ViewSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets); - + void onError(Exception error); } @@ -10958,12 +10958,12 @@ public void resetWatermarks(DefaultClusterCallback callback } public void resetWatermarks(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetWatermarks(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetWatermarks(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface ThreadMetricsAttributeCallback { @@ -11267,7 +11267,7 @@ private native void navigateTargetRequest(long chipClusterPtr, NavigateTargetRes , @Nullable Integer timedInvokeTimeoutMs); public interface NavigateTargetResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } @@ -11518,7 +11518,7 @@ public void test(DefaultClusterCallback callback } public void test(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { test(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11628,7 +11628,7 @@ public void testNotHandled(DefaultClusterCallback callback } public void testNotHandled(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11661,7 +11661,7 @@ public void testSpecific(TestSpecificResponseCallback callback } public void testSpecific(TestSpecificResponseCallback callback - + , int timedInvokeTimeoutMs) { testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11683,14 +11683,14 @@ public void testUnknownCommand(DefaultClusterCallback callback } public void testUnknownCommand(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); } public void timedInvokeRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11698,7 +11698,7 @@ private native void simpleStructEchoRequest(long chipClusterPtr, SimpleStructRes , ChipStructs.TestClusterClusterSimpleStruct arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void test(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void testAddArguments(long chipClusterPtr, TestAddArgumentsResponseCallback Callback , Integer arg1, Integer arg2 @@ -11728,7 +11728,7 @@ private native void testNestedStructListArgumentRequest(long chipClusterPtr, Boo , ChipStructs.TestClusterClusterNestedStructList arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void testNotHandled(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void testNullableOptionalRequest(long chipClusterPtr, TestNullableOptionalResponseCallback Callback , @Nullable Optional arg1 @@ -11737,62 +11737,62 @@ private native void testSimpleOptionalArgumentRequest(long chipClusterPtr, Defau , Optional arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void testSpecific(long chipClusterPtr, TestSpecificResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void testStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback , ChipStructs.TestClusterClusterSimpleStruct arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void testUnknownCommand(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void timedInvokeRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface BooleanResponseCallback { void onSuccess(Boolean value); - + void onError(Exception error); } public interface SimpleStructResponseCallback { void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); - + void onError(Exception error); } public interface TestAddArgumentsResponseCallback { void onSuccess(Integer returnValue); - + void onError(Exception error); } public interface TestEmitTestEventResponseCallback { void onSuccess(Long value); - + void onError(Exception error); } public interface TestEnumsResponseCallback { void onSuccess(Integer arg1, Integer arg2); - + void onError(Exception error); } public interface TestListInt8UReverseResponseCallback { void onSuccess(ArrayList arg1); - + void onError(Exception error); } public interface TestNullableOptionalResponseCallback { void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue); - + void onError(Exception error); } public interface TestSpecificResponseCallback { void onSuccess(Integer returnValue); - + void onError(Exception error); } @@ -14220,7 +14220,7 @@ public void clearWeeklySchedule(DefaultClusterCallback callback } public void clearWeeklySchedule(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { clearWeeklySchedule(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -14231,7 +14231,7 @@ public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback } public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback - + , int timedInvokeTimeoutMs) { getRelayStatusLog(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -14269,10 +14269,10 @@ public void setpointRaiseLower(DefaultClusterCallback callback setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs); } private native void clearWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void getRelayStatusLog(long chipClusterPtr, GetRelayStatusLogResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void getWeeklySchedule(long chipClusterPtr, GetWeeklyScheduleResponseCallback Callback , Integer daysToReturn, Integer modeToReturn @@ -14285,13 +14285,13 @@ private native void setpointRaiseLower(long chipClusterPtr, DefaultClusterCallba , @Nullable Integer timedInvokeTimeoutMs); public interface GetRelayStatusLogResponseCallback { void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries); - + void onError(Exception error); } public interface GetWeeklyScheduleResponseCallback { void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload); - + void onError(Exception error); } @@ -14919,12 +14919,12 @@ public void resetCounts(DefaultClusterCallback callback } public void resetCounts(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface NeighborTableListAttributeCallback { @@ -16556,12 +16556,12 @@ public void resetCounts(DefaultClusterCallback callback } public void resetCounts(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -16891,7 +16891,7 @@ public void downOrClose(DefaultClusterCallback callback } public void downOrClose(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { downOrClose(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -16946,7 +16946,7 @@ public void stopMotion(DefaultClusterCallback callback } public void stopMotion(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { stopMotion(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -16957,12 +16957,12 @@ public void upOrOpen(DefaultClusterCallback callback } public void upOrOpen(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { upOrOpen(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void downOrClose(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void goToLiftPercentage(long chipClusterPtr, DefaultClusterCallback Callback , Integer liftPercentageValue, Integer liftPercent100thsValue @@ -16977,10 +16977,10 @@ private native void goToTiltValue(long chipClusterPtr, DefaultClusterCallback Ca , Integer tiltValue , @Nullable Integer timedInvokeTimeoutMs); private native void stopMotion(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void upOrOpen(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface CurrentPositionLiftAttributeCallback { diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java index 23446754ab399f..19853055a448c2 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java @@ -2130,4 +2130,4 @@ public String toString() { } } -} \ No newline at end of file +} diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index 206c331e05b755..36b3755afb50ea 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -1024,7 +1024,7 @@ public void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Lo responseValues.put(userTypeResponseValue, userType); CommandResponseInfo credentialRuleResponseValue = new CommandResponseInfo("credentialRule", "Integer"); responseValues.put(credentialRuleResponseValue, credentialRule); - // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * + // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet CommandResponseInfo creatorFabricIndexResponseValue = new CommandResponseInfo("creatorFabricIndex", "Integer"); responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); @@ -1479,7 +1479,7 @@ public void setCallbackDelegate(ClusterCommandCallback callback) { @Override public void onSuccess(ArrayList groupKeySetIDs) { Map responseValues = new LinkedHashMap<>(); - // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * + // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -1609,7 +1609,7 @@ public void onSuccess(Integer capacity, ArrayList groupList) { Map responseValues = new LinkedHashMap<>(); CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); responseValues.put(capacityResponseValue, capacity); - // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * + // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -2045,9 +2045,9 @@ public void onSuccess(Integer NetworkingStatus, String DebugText, Optional arg1) { Map responseValues = new LinkedHashMap<>(); - // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * + // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -3258,7 +3258,7 @@ public void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekF responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); CommandResponseInfo modeForSequenceResponseValue = new CommandResponseInfo("modeForSequence", "Integer"); responseValues.put(modeForSequenceResponseValue, modeForSequence); - // payload: /* TYPE WARNING: array array defaults to */ uint8_t * + // payload: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -3824,7 +3824,7 @@ public Map> getCommandMap() { Map accountLogingetSetupPINRequestCommandParams = new LinkedHashMap(); CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); accountLogingetSetupPINRequestCommandParams.put("tempAccountIdentifier",accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); - + InteractionInfo accountLogingetSetupPINRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AccountLoginCluster) cluster) @@ -3841,10 +3841,10 @@ public Map> getCommandMap() { Map accountLoginloginRequestCommandParams = new LinkedHashMap(); CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); accountLoginloginRequestCommandParams.put("tempAccountIdentifier",accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); - + CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = new CommandParameterInfo("setupPIN", String.class); accountLoginloginRequestCommandParams.put("setupPIN",accountLoginloginRequestsetupPINCommandParameterInfo); - + InteractionInfo accountLoginloginRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AccountLoginCluster) cluster) @@ -3877,7 +3877,7 @@ public Map> getCommandMap() { Map administratorCommissioningopenBasicCommissioningWindowCommandParams = new LinkedHashMap(); CommandParameterInfo administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); administratorCommissioningopenBasicCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); - + InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AdministratorCommissioningCluster) cluster) @@ -3894,22 +3894,22 @@ public Map> getCommandMap() { Map administratorCommissioningopenCommissioningWindowCommandParams = new LinkedHashMap(); CommandParameterInfo administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); administratorCommissioningopenCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = new CommandParameterInfo("PAKEVerifier", byte[].class); administratorCommissioningopenCommissioningWindowCommandParams.put("PAKEVerifier",administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = new CommandParameterInfo("discriminator", Integer.class); administratorCommissioningopenCommissioningWindowCommandParams.put("discriminator",administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = new CommandParameterInfo("iterations", Long.class); administratorCommissioningopenCommissioningWindowCommandParams.put("iterations",administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = new CommandParameterInfo("salt", byte[].class); administratorCommissioningopenCommissioningWindowCommandParams.put("salt",administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = new CommandParameterInfo("passcodeID", Integer.class); administratorCommissioningopenCommissioningWindowCommandParams.put("passcodeID",administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); - + InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AdministratorCommissioningCluster) cluster) @@ -3956,7 +3956,7 @@ public Map> getCommandMap() { .hideAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) commandArguments.get("application") - + ); }, () -> new DelegatedLauncherResponseCallback(), @@ -3966,7 +3966,7 @@ public Map> getCommandMap() { Map applicationLauncherlaunchAppRequestCommandParams = new LinkedHashMap(); CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); applicationLauncherlaunchAppRequestCommandParams.put("data",applicationLauncherlaunchAppRequestdataCommandParameterInfo); - + InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationLauncherCluster) cluster) @@ -3975,7 +3975,7 @@ public Map> getCommandMap() { commandArguments.get("data") , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) commandArguments.get("application") - + ); }, () -> new DelegatedLauncherResponseCallback(), @@ -3989,7 +3989,7 @@ public Map> getCommandMap() { .stopAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) commandArguments.get("application") - + ); }, () -> new DelegatedLauncherResponseCallback(), @@ -4001,10 +4001,10 @@ public Map> getCommandMap() { Map audioOutputrenameOutputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); audioOutputrenameOutputRequestCommandParams.put("index",audioOutputrenameOutputRequestindexCommandParameterInfo); - + CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); audioOutputrenameOutputRequestCommandParams.put("name",audioOutputrenameOutputRequestnameCommandParameterInfo); - + InteractionInfo audioOutputrenameOutputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AudioOutputCluster) cluster) @@ -4013,7 +4013,7 @@ public Map> getCommandMap() { commandArguments.get("index") , (String) commandArguments.get("name") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4023,14 +4023,14 @@ public Map> getCommandMap() { Map audioOutputselectOutputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); audioOutputselectOutputRequestCommandParams.put("index",audioOutputselectOutputRequestindexCommandParameterInfo); - + InteractionInfo audioOutputselectOutputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AudioOutputCluster) cluster) .selectOutputRequest((DefaultClusterCallback) callback , (Integer) commandArguments.get("index") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4042,14 +4042,14 @@ public Map> getCommandMap() { Map barrierControlbarrierControlGoToPercentCommandParams = new LinkedHashMap(); CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = new CommandParameterInfo("percentOpen", Integer.class); barrierControlbarrierControlGoToPercentCommandParams.put("percentOpen",barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); - + InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .barrierControlGoToPercent((DefaultClusterCallback) callback , (Integer) commandArguments.get("percentOpen") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4061,7 +4061,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .barrierControlStop((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4077,16 +4077,16 @@ public Map> getCommandMap() { Map bindingbindCommandParams = new LinkedHashMap(); CommandParameterInfo bindingbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); bindingbindCommandParams.put("nodeId",bindingbindnodeIdCommandParameterInfo); - + CommandParameterInfo bindingbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); bindingbindCommandParams.put("groupId",bindingbindgroupIdCommandParameterInfo); - + CommandParameterInfo bindingbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); bindingbindCommandParams.put("endpointId",bindingbindendpointIdCommandParameterInfo); - + CommandParameterInfo bindingbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); bindingbindCommandParams.put("clusterId",bindingbindclusterIdCommandParameterInfo); - + InteractionInfo bindingbindInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BindingCluster) cluster) @@ -4099,7 +4099,7 @@ public Map> getCommandMap() { commandArguments.get("endpointId") , (Long) commandArguments.get("clusterId") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4109,16 +4109,16 @@ public Map> getCommandMap() { Map bindingunbindCommandParams = new LinkedHashMap(); CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); bindingunbindCommandParams.put("nodeId",bindingunbindnodeIdCommandParameterInfo); - + CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); bindingunbindCommandParams.put("groupId",bindingunbindgroupIdCommandParameterInfo); - + CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); bindingunbindCommandParams.put("endpointId",bindingunbindendpointIdCommandParameterInfo); - + CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); bindingunbindCommandParams.put("clusterId",bindingunbindclusterIdCommandParameterInfo); - + InteractionInfo bindingunbindInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BindingCluster) cluster) @@ -4131,7 +4131,7 @@ public Map> getCommandMap() { commandArguments.get("endpointId") , (Long) commandArguments.get("clusterId") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4145,10 +4145,10 @@ public Map> getCommandMap() { Map bridgedActionsdisableActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsdisableActionCommandParams.put("actionID",bridgedActionsdisableActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsdisableActionCommandParams.put("invokeID",bridgedActionsdisableActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsdisableActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4157,7 +4157,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4167,13 +4167,13 @@ public Map> getCommandMap() { Map bridgedActionsdisableActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsdisableActionWithDurationCommandParams.put("actionID",bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsdisableActionWithDurationCommandParams.put("invokeID",bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionsdisableActionWithDurationCommandParams.put("duration",bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4184,7 +4184,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4194,10 +4194,10 @@ public Map> getCommandMap() { Map bridgedActionsenableActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsenableActionCommandParams.put("actionID",bridgedActionsenableActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsenableActionCommandParams.put("invokeID",bridgedActionsenableActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsenableActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4206,7 +4206,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4216,13 +4216,13 @@ public Map> getCommandMap() { Map bridgedActionsenableActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsenableActionWithDurationCommandParams.put("actionID",bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsenableActionWithDurationCommandParams.put("invokeID",bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionsenableActionWithDurationCommandParams.put("duration",bridgedActionsenableActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4233,7 +4233,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4243,10 +4243,10 @@ public Map> getCommandMap() { Map bridgedActionsinstantActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsinstantActionCommandParams.put("actionID",bridgedActionsinstantActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsinstantActionCommandParams.put("invokeID",bridgedActionsinstantActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsinstantActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4255,7 +4255,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4265,13 +4265,13 @@ public Map> getCommandMap() { Map bridgedActionsinstantActionWithTransitionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsinstantActionWithTransitionCommandParams.put("actionID",bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsinstantActionWithTransitionCommandParams.put("invokeID",bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); bridgedActionsinstantActionWithTransitionCommandParams.put("transitionTime",bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); - + InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4282,7 +4282,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4292,10 +4292,10 @@ public Map> getCommandMap() { Map bridgedActionspauseActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionspauseActionCommandParams.put("actionID",bridgedActionspauseActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionspauseActionCommandParams.put("invokeID",bridgedActionspauseActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionspauseActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4304,7 +4304,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4314,13 +4314,13 @@ public Map> getCommandMap() { Map bridgedActionspauseActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionspauseActionWithDurationCommandParams.put("actionID",bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionspauseActionWithDurationCommandParams.put("invokeID",bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionspauseActionWithDurationCommandParams.put("duration",bridgedActionspauseActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4331,7 +4331,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4341,10 +4341,10 @@ public Map> getCommandMap() { Map bridgedActionsresumeActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsresumeActionCommandParams.put("actionID",bridgedActionsresumeActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsresumeActionCommandParams.put("invokeID",bridgedActionsresumeActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsresumeActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4353,7 +4353,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4363,10 +4363,10 @@ public Map> getCommandMap() { Map bridgedActionsstartActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsstartActionCommandParams.put("actionID",bridgedActionsstartActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsstartActionCommandParams.put("invokeID",bridgedActionsstartActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsstartActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4375,7 +4375,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4385,13 +4385,13 @@ public Map> getCommandMap() { Map bridgedActionsstartActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsstartActionWithDurationCommandParams.put("actionID",bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsstartActionWithDurationCommandParams.put("invokeID",bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionsstartActionWithDurationCommandParams.put("duration",bridgedActionsstartActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4402,7 +4402,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4412,10 +4412,10 @@ public Map> getCommandMap() { Map bridgedActionsstopActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsstopActionCommandParams.put("actionID",bridgedActionsstopActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsstopActionCommandParams.put("invokeID",bridgedActionsstopActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsstopActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4424,7 +4424,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4438,10 +4438,10 @@ public Map> getCommandMap() { Map channelchangeChannelByNumberRequestCommandParams = new LinkedHashMap(); CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = new CommandParameterInfo("majorNumber", Integer.class); channelchangeChannelByNumberRequestCommandParams.put("majorNumber",channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); - + CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = new CommandParameterInfo("minorNumber", Integer.class); channelchangeChannelByNumberRequestCommandParams.put("minorNumber",channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); - + InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ChannelCluster) cluster) @@ -4450,7 +4450,7 @@ public Map> getCommandMap() { commandArguments.get("majorNumber") , (Integer) commandArguments.get("minorNumber") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4460,14 +4460,14 @@ public Map> getCommandMap() { Map channelchangeChannelRequestCommandParams = new LinkedHashMap(); CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = new CommandParameterInfo("match", String.class); channelchangeChannelRequestCommandParams.put("match",channelchangeChannelRequestmatchCommandParameterInfo); - + InteractionInfo channelchangeChannelRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ChannelCluster) cluster) .changeChannelRequest((ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback , (String) commandArguments.get("match") - + ); }, () -> new DelegatedChangeChannelResponseCallback(), @@ -4477,14 +4477,14 @@ public Map> getCommandMap() { Map channelskipChannelRequestCommandParams = new LinkedHashMap(); CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = new CommandParameterInfo("count", Integer.class); channelskipChannelRequestCommandParams.put("count",channelskipChannelRequestcountCommandParameterInfo); - + InteractionInfo channelskipChannelRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ChannelCluster) cluster) .skipChannelRequest((DefaultClusterCallback) callback , (Integer) commandArguments.get("count") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4496,25 +4496,25 @@ public Map> getCommandMap() { Map colorControlcolorLoopSetCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = new CommandParameterInfo("updateFlags", Integer.class); colorControlcolorLoopSetCommandParams.put("updateFlags",colorControlcolorLoopSetupdateFlagsCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = new CommandParameterInfo("action", Integer.class); colorControlcolorLoopSetCommandParams.put("action",colorControlcolorLoopSetactionCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); colorControlcolorLoopSetCommandParams.put("direction",colorControlcolorLoopSetdirectionCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = new CommandParameterInfo("time", Integer.class); colorControlcolorLoopSetCommandParams.put("time",colorControlcolorLoopSettimeCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = new CommandParameterInfo("startHue", Integer.class); colorControlcolorLoopSetCommandParams.put("startHue",colorControlcolorLoopSetstartHueCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlcolorLoopSetCommandParams.put("optionsMask",colorControlcolorLoopSetoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlcolorLoopSetCommandParams.put("optionsOverride",colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlcolorLoopSetInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4533,7 +4533,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4543,16 +4543,16 @@ public Map> getCommandMap() { Map colorControlenhancedMoveHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlenhancedMoveHueCommandParams.put("moveMode",colorControlenhancedMoveHuemoveModeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlenhancedMoveHueCommandParams.put("rate",colorControlenhancedMoveHuerateCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedMoveHueCommandParams.put("optionsMask",colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedMoveHueCommandParams.put("optionsOverride",colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedMoveHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4565,7 +4565,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4575,19 +4575,19 @@ public Map> getCommandMap() { Map colorControlenhancedMoveToHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); colorControlenhancedMoveToHueCommandParams.put("enhancedHue",colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); colorControlenhancedMoveToHueCommandParams.put("direction",colorControlenhancedMoveToHuedirectionCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlenhancedMoveToHueCommandParams.put("transitionTime",colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedMoveToHueCommandParams.put("optionsMask",colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedMoveToHueCommandParams.put("optionsOverride",colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedMoveToHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4602,7 +4602,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4612,19 +4612,19 @@ public Map> getCommandMap() { Map colorControlenhancedMoveToHueAndSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("enhancedHue",colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("saturation",colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("transitionTime",colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsMask",colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4639,7 +4639,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4649,19 +4649,19 @@ public Map> getCommandMap() { Map colorControlenhancedStepHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlenhancedStepHueCommandParams.put("stepMode",colorControlenhancedStepHuestepModeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlenhancedStepHueCommandParams.put("stepSize",colorControlenhancedStepHuestepSizeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlenhancedStepHueCommandParams.put("transitionTime",colorControlenhancedStepHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedStepHueCommandParams.put("optionsMask",colorControlenhancedStepHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedStepHueCommandParams.put("optionsOverride",colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedStepHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4676,7 +4676,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4686,16 +4686,16 @@ public Map> getCommandMap() { Map colorControlmoveColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = new CommandParameterInfo("rateX", Integer.class); colorControlmoveColorCommandParams.put("rateX",colorControlmoveColorrateXCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = new CommandParameterInfo("rateY", Integer.class); colorControlmoveColorCommandParams.put("rateY",colorControlmoveColorrateYCommandParameterInfo); - + CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveColorCommandParams.put("optionsMask",colorControlmoveColoroptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveColorCommandParams.put("optionsOverride",colorControlmoveColoroptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveColorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4708,7 +4708,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4718,22 +4718,22 @@ public Map> getCommandMap() { Map colorControlmoveColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlmoveColorTemperatureCommandParams.put("moveMode",colorControlmoveColorTemperaturemoveModeCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlmoveColorTemperatureCommandParams.put("rate",colorControlmoveColorTemperaturerateCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveColorTemperatureCommandParams.put("optionsMask",colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveColorTemperatureCommandParams.put("optionsOverride",colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveColorTemperatureInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4750,7 +4750,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4760,16 +4760,16 @@ public Map> getCommandMap() { Map colorControlmoveHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlmoveHueCommandParams.put("moveMode",colorControlmoveHuemoveModeCommandParameterInfo); - + CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlmoveHueCommandParams.put("rate",colorControlmoveHuerateCommandParameterInfo); - + CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveHueCommandParams.put("optionsMask",colorControlmoveHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveHueCommandParams.put("optionsOverride",colorControlmoveHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4782,7 +4782,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4792,16 +4792,16 @@ public Map> getCommandMap() { Map colorControlmoveSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlmoveSaturationCommandParams.put("moveMode",colorControlmoveSaturationmoveModeCommandParameterInfo); - + CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlmoveSaturationCommandParams.put("rate",colorControlmoveSaturationrateCommandParameterInfo); - + CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveSaturationCommandParams.put("optionsMask",colorControlmoveSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveSaturationCommandParams.put("optionsOverride",colorControlmoveSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4814,7 +4814,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4824,19 +4824,19 @@ public Map> getCommandMap() { Map colorControlmoveToColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = new CommandParameterInfo("colorX", Integer.class); colorControlmoveToColorCommandParams.put("colorX",colorControlmoveToColorcolorXCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = new CommandParameterInfo("colorY", Integer.class); colorControlmoveToColorCommandParams.put("colorY",colorControlmoveToColorcolorYCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToColorCommandParams.put("transitionTime",colorControlmoveToColortransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToColorCommandParams.put("optionsMask",colorControlmoveToColoroptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToColorCommandParams.put("optionsOverride",colorControlmoveToColoroptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToColorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4851,7 +4851,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4861,16 +4861,16 @@ public Map> getCommandMap() { Map colorControlmoveToColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = new CommandParameterInfo("colorTemperature", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("colorTemperature",colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("transitionTime",colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("optionsMask",colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("optionsOverride",colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4883,7 +4883,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4893,19 +4893,19 @@ public Map> getCommandMap() { Map colorControlmoveToHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); colorControlmoveToHueCommandParams.put("hue",colorControlmoveToHuehueCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); colorControlmoveToHueCommandParams.put("direction",colorControlmoveToHuedirectionCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToHueCommandParams.put("transitionTime",colorControlmoveToHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToHueCommandParams.put("optionsMask",colorControlmoveToHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToHueCommandParams.put("optionsOverride",colorControlmoveToHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4920,7 +4920,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4930,19 +4930,19 @@ public Map> getCommandMap() { Map colorControlmoveToHueAndSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("hue",colorControlmoveToHueAndSaturationhueCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("saturation",colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("transitionTime",colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("optionsMask",colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4957,7 +4957,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4967,16 +4967,16 @@ public Map> getCommandMap() { Map colorControlmoveToSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); colorControlmoveToSaturationCommandParams.put("saturation",colorControlmoveToSaturationsaturationCommandParameterInfo); - + CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToSaturationCommandParams.put("transitionTime",colorControlmoveToSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToSaturationCommandParams.put("optionsMask",colorControlmoveToSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToSaturationCommandParams.put("optionsOverride",colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4989,7 +4989,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4999,19 +4999,19 @@ public Map> getCommandMap() { Map colorControlstepColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = new CommandParameterInfo("stepX", Integer.class); colorControlstepColorCommandParams.put("stepX",colorControlstepColorstepXCommandParameterInfo); - + CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = new CommandParameterInfo("stepY", Integer.class); colorControlstepColorCommandParams.put("stepY",colorControlstepColorstepYCommandParameterInfo); - + CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepColorCommandParams.put("transitionTime",colorControlstepColortransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepColorCommandParams.put("optionsMask",colorControlstepColoroptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepColorCommandParams.put("optionsOverride",colorControlstepColoroptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepColorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5026,7 +5026,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5036,25 +5036,25 @@ public Map> getCommandMap() { Map colorControlstepColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlstepColorTemperatureCommandParams.put("stepMode",colorControlstepColorTemperaturestepModeCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlstepColorTemperatureCommandParams.put("stepSize",colorControlstepColorTemperaturestepSizeCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepColorTemperatureCommandParams.put("transitionTime",colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); colorControlstepColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); colorControlstepColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepColorTemperatureCommandParams.put("optionsMask",colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepColorTemperatureCommandParams.put("optionsOverride",colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepColorTemperatureInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5073,7 +5073,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5083,19 +5083,19 @@ public Map> getCommandMap() { Map colorControlstepHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlstepHueCommandParams.put("stepMode",colorControlstepHuestepModeCommandParameterInfo); - + CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlstepHueCommandParams.put("stepSize",colorControlstepHuestepSizeCommandParameterInfo); - + CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepHueCommandParams.put("transitionTime",colorControlstepHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepHueCommandParams.put("optionsMask",colorControlstepHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepHueCommandParams.put("optionsOverride",colorControlstepHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5110,7 +5110,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5120,19 +5120,19 @@ public Map> getCommandMap() { Map colorControlstepSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlstepSaturationCommandParams.put("stepMode",colorControlstepSaturationstepModeCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlstepSaturationCommandParams.put("stepSize",colorControlstepSaturationstepSizeCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepSaturationCommandParams.put("transitionTime",colorControlstepSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepSaturationCommandParams.put("optionsMask",colorControlstepSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepSaturationCommandParams.put("optionsOverride",colorControlstepSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5147,7 +5147,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5157,10 +5157,10 @@ public Map> getCommandMap() { Map colorControlstopMoveStepCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstopMoveStepCommandParams.put("optionsMask",colorControlstopMoveStepoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstopMoveStepCommandParams.put("optionsOverride",colorControlstopMoveStepoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstopMoveStepInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5169,7 +5169,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5181,10 +5181,10 @@ public Map> getCommandMap() { Map contentLauncherlaunchContentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = new CommandParameterInfo("autoPlay", Boolean.class); contentLauncherlaunchContentRequestCommandParams.put("autoPlay",contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); - + CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); contentLauncherlaunchContentRequestCommandParams.put("data",contentLauncherlaunchContentRequestdataCommandParameterInfo); - + InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ContentLauncherCluster) cluster) @@ -5195,7 +5195,7 @@ public Map> getCommandMap() { commandArguments.get("data") , (ArrayList) commandArguments.get("search") - + ); }, () -> new DelegatedLaunchResponseCallback(), @@ -5205,10 +5205,10 @@ public Map> getCommandMap() { Map contentLauncherlaunchURLRequestCommandParams = new LinkedHashMap(); CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = new CommandParameterInfo("contentURL", String.class); contentLauncherlaunchURLRequestCommandParams.put("contentURL",contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); - + CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = new CommandParameterInfo("displayString", String.class); contentLauncherlaunchURLRequestCommandParams.put("displayString",contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); - + InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ContentLauncherCluster) cluster) @@ -5219,7 +5219,7 @@ public Map> getCommandMap() { commandArguments.get("displayString") , (ChipStructs.ContentLauncherClusterBrandingInformation) commandArguments.get("brandingInformation") - + ); }, () -> new DelegatedLaunchResponseCallback(), @@ -5233,13 +5233,13 @@ public Map> getCommandMap() { Map diagnosticLogsretrieveLogsRequestCommandParams = new LinkedHashMap(); CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = new CommandParameterInfo("intent", Integer.class); diagnosticLogsretrieveLogsRequestCommandParams.put("intent",diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); - + CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = new CommandParameterInfo("requestedProtocol", Integer.class); diagnosticLogsretrieveLogsRequestCommandParams.put("requestedProtocol",diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); - + CommandParameterInfo diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = new CommandParameterInfo("transferFileDesignator", byte[].class); diagnosticLogsretrieveLogsRequestCommandParams.put("transferFileDesignator",diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); - + InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DiagnosticLogsCluster) cluster) @@ -5250,7 +5250,7 @@ public Map> getCommandMap() { commandArguments.get("requestedProtocol") , (byte[]) commandArguments.get("transferFileDesignator") - + ); }, () -> new DelegatedRetrieveLogsResponseCallback(), @@ -5276,7 +5276,7 @@ public Map> getCommandMap() { Map doorLockclearUserCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockclearUserCommandParams.put("userIndex",doorLockclearUseruserIndexCommandParameterInfo); - + InteractionInfo doorLockclearUserInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5293,10 +5293,10 @@ public Map> getCommandMap() { Map doorLockclearWeekDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); doorLockclearWeekDayScheduleCommandParams.put("weekDayIndex",doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockclearWeekDayScheduleCommandParams.put("userIndex",doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5305,7 +5305,7 @@ public Map> getCommandMap() { commandArguments.get("weekDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5315,10 +5315,10 @@ public Map> getCommandMap() { Map doorLockclearYearDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); doorLockclearYearDayScheduleCommandParams.put("yearDayIndex",doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockclearYearDayScheduleCommandParams.put("userIndex",doorLockclearYearDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockclearYearDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5327,7 +5327,7 @@ public Map> getCommandMap() { commandArguments.get("yearDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5341,7 +5341,7 @@ public Map> getCommandMap() { .getCredentialStatus((ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback , (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential") - + ); }, () -> new DelegatedGetCredentialStatusResponseCallback(), @@ -5351,14 +5351,14 @@ public Map> getCommandMap() { Map doorLockgetUserCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockgetUserCommandParams.put("userIndex",doorLockgetUseruserIndexCommandParameterInfo); - + InteractionInfo doorLockgetUserInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .getUser((ChipClusters.DoorLockCluster.GetUserResponseCallback) callback , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedGetUserResponseCallback(), @@ -5368,10 +5368,10 @@ public Map> getCommandMap() { Map doorLockgetWeekDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); doorLockgetWeekDayScheduleCommandParams.put("weekDayIndex",doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockgetWeekDayScheduleCommandParams.put("userIndex",doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5380,7 +5380,7 @@ public Map> getCommandMap() { commandArguments.get("weekDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedGetWeekDayScheduleResponseCallback(), @@ -5390,10 +5390,10 @@ public Map> getCommandMap() { Map doorLockgetYearDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); doorLockgetYearDayScheduleCommandParams.put("yearDayIndex",doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockgetYearDayScheduleCommandParams.put("userIndex",doorLockgetYearDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockgetYearDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5402,7 +5402,7 @@ public Map> getCommandMap() { commandArguments.get("yearDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedGetYearDayScheduleResponseCallback(), @@ -5412,7 +5412,7 @@ public Map> getCommandMap() { Map doorLocklockDoorCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); doorLocklockDoorCommandParams.put("pinCode",doorLocklockDoorpinCodeCommandParameterInfo); - + InteractionInfo doorLocklockDoorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5429,19 +5429,19 @@ public Map> getCommandMap() { Map doorLocksetCredentialCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); doorLocksetCredentialCommandParams.put("operationType",doorLocksetCredentialoperationTypeCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = new CommandParameterInfo("credentialData", byte[].class); doorLocksetCredentialCommandParams.put("credentialData",doorLocksetCredentialcredentialDataCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetCredentialCommandParams.put("userIndex",doorLocksetCredentialuserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); doorLocksetCredentialCommandParams.put("userStatus",doorLocksetCredentialuserStatusCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); doorLocksetCredentialCommandParams.put("userType",doorLocksetCredentialuserTypeCommandParameterInfo); - + InteractionInfo doorLocksetCredentialInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5468,25 +5468,25 @@ public Map> getCommandMap() { Map doorLocksetUserCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); doorLocksetUserCommandParams.put("operationType",doorLocksetUseroperationTypeCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetUserCommandParams.put("userIndex",doorLocksetUseruserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = new CommandParameterInfo("userName", String.class); doorLocksetUserCommandParams.put("userName",doorLocksetUseruserNameCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = new CommandParameterInfo("userUniqueId", Long.class); doorLocksetUserCommandParams.put("userUniqueId",doorLocksetUseruserUniqueIdCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); doorLocksetUserCommandParams.put("userStatus",doorLocksetUseruserStatusCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); doorLocksetUserCommandParams.put("userType",doorLocksetUseruserTypeCommandParameterInfo); - + CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = new CommandParameterInfo("credentialRule", Integer.class); doorLocksetUserCommandParams.put("credentialRule",doorLocksetUsercredentialRuleCommandParameterInfo); - + InteractionInfo doorLocksetUserInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5515,25 +5515,25 @@ public Map> getCommandMap() { Map doorLocksetWeekDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("weekDayIndex",doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("userIndex",doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = new CommandParameterInfo("daysMask", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("daysMask",doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = new CommandParameterInfo("startHour", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("startHour",doorLocksetWeekDaySchedulestartHourCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = new CommandParameterInfo("startMinute", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("startMinute",doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = new CommandParameterInfo("endHour", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("endHour",doorLocksetWeekDayScheduleendHourCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = new CommandParameterInfo("endMinute", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("endMinute",doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); - + InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5552,7 +5552,7 @@ public Map> getCommandMap() { commandArguments.get("endHour") , (Integer) commandArguments.get("endMinute") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5562,16 +5562,16 @@ public Map> getCommandMap() { Map doorLocksetYearDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); doorLocksetYearDayScheduleCommandParams.put("yearDayIndex",doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetYearDayScheduleCommandParams.put("userIndex",doorLocksetYearDayScheduleuserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = new CommandParameterInfo("localStartTime", Long.class); doorLocksetYearDayScheduleCommandParams.put("localStartTime",doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); - + CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = new CommandParameterInfo("localEndTime", Long.class); doorLocksetYearDayScheduleCommandParams.put("localEndTime",doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); - + InteractionInfo doorLocksetYearDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5584,7 +5584,7 @@ public Map> getCommandMap() { commandArguments.get("localStartTime") , (Long) commandArguments.get("localEndTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5594,7 +5594,7 @@ public Map> getCommandMap() { Map doorLockunlockDoorCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); doorLockunlockDoorCommandParams.put("pinCode",doorLockunlockDoorpinCodeCommandParameterInfo); - + InteractionInfo doorLockunlockDoorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5611,10 +5611,10 @@ public Map> getCommandMap() { Map doorLockunlockWithTimeoutCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = new CommandParameterInfo("timeout", Integer.class); doorLockunlockWithTimeoutCommandParams.put("timeout",doorLockunlockWithTimeouttimeoutCommandParameterInfo); - + CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); doorLockunlockWithTimeoutCommandParams.put("pinCode",doorLockunlockWithTimeoutpinCodeCommandParameterInfo); - + InteractionInfo doorLockunlockWithTimeoutInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5639,7 +5639,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .resetCounts((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5655,13 +5655,13 @@ public Map> getCommandMap() { Map generalCommissioningarmFailSafeCommandParams = new LinkedHashMap(); CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = new CommandParameterInfo("expiryLengthSeconds", Integer.class); generalCommissioningarmFailSafeCommandParams.put("expiryLengthSeconds",generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); - + CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); generalCommissioningarmFailSafeCommandParams.put("breadcrumb",generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); - + CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); generalCommissioningarmFailSafeCommandParams.put("timeoutMs",generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); - + InteractionInfo generalCommissioningarmFailSafeInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) @@ -5672,7 +5672,7 @@ public Map> getCommandMap() { commandArguments.get("breadcrumb") , (Long) commandArguments.get("timeoutMs") - + ); }, () -> new DelegatedArmFailSafeResponseCallback(), @@ -5684,7 +5684,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) .commissioningComplete((ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback) callback - + ); }, () -> new DelegatedCommissioningCompleteResponseCallback(), @@ -5694,16 +5694,16 @@ public Map> getCommandMap() { Map generalCommissioningsetRegulatoryConfigCommandParams = new LinkedHashMap(); CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = new CommandParameterInfo("location", Integer.class); generalCommissioningsetRegulatoryConfigCommandParams.put("location",generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); - + CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = new CommandParameterInfo("countryCode", String.class); generalCommissioningsetRegulatoryConfigCommandParams.put("countryCode",generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); - + CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); generalCommissioningsetRegulatoryConfigCommandParams.put("breadcrumb",generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); - + CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); generalCommissioningsetRegulatoryConfigCommandParams.put("timeoutMs",generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); - + InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) @@ -5716,7 +5716,7 @@ public Map> getCommandMap() { commandArguments.get("breadcrumb") , (Long) commandArguments.get("timeoutMs") - + ); }, () -> new DelegatedSetRegulatoryConfigResponseCallback(), @@ -5730,14 +5730,14 @@ public Map> getCommandMap() { Map groupKeyManagementkeySetReadCommandParams = new LinkedHashMap(); CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); groupKeyManagementkeySetReadCommandParams.put("groupKeySetID",groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); - + InteractionInfo groupKeyManagementkeySetReadInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .keySetRead((ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback , (Integer) commandArguments.get("groupKeySetID") - + ); }, () -> new DelegatedKeySetReadResponseCallback(), @@ -5747,14 +5747,14 @@ public Map> getCommandMap() { Map groupKeyManagementkeySetReadAllIndicesCommandParams = new LinkedHashMap(); CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = new CommandParameterInfo("groupKeySetIDs", ArrayList.class); groupKeyManagementkeySetReadAllIndicesCommandParams.put("groupKeySetIDs",groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); - + InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .keySetReadAllIndices((ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) callback , (ArrayList) commandArguments.get("groupKeySetIDs") - + ); }, () -> new DelegatedKeySetReadAllIndicesResponseCallback(), @@ -5764,14 +5764,14 @@ public Map> getCommandMap() { Map groupKeyManagementkeySetRemoveCommandParams = new LinkedHashMap(); CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); groupKeyManagementkeySetRemoveCommandParams.put("groupKeySetID",groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); - + InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .keySetRemove((DefaultClusterCallback) callback , (Integer) commandArguments.get("groupKeySetID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5785,7 +5785,7 @@ public Map> getCommandMap() { .keySetWrite((DefaultClusterCallback) callback , (ChipStructs.GroupKeyManagementClusterGroupKeySet) commandArguments.get("groupKeySet") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5797,10 +5797,10 @@ public Map> getCommandMap() { Map groupsaddGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsaddGroupCommandParams.put("groupId",groupsaddGroupgroupIdCommandParameterInfo); - + CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); groupsaddGroupCommandParams.put("groupName",groupsaddGroupgroupNameCommandParameterInfo); - + InteractionInfo groupsaddGroupInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) @@ -5809,7 +5809,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (String) commandArguments.get("groupName") - + ); }, () -> new DelegatedAddGroupResponseCallback(), @@ -5819,10 +5819,10 @@ public Map> getCommandMap() { Map groupsaddGroupIfIdentifyingCommandParams = new LinkedHashMap(); CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsaddGroupIfIdentifyingCommandParams.put("groupId",groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); - + CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); groupsaddGroupIfIdentifyingCommandParams.put("groupName",groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); - + InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) @@ -5831,7 +5831,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (String) commandArguments.get("groupName") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5841,14 +5841,14 @@ public Map> getCommandMap() { Map groupsgetGroupMembershipCommandParams = new LinkedHashMap(); CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = new CommandParameterInfo("groupList", ArrayList.class); groupsgetGroupMembershipCommandParams.put("groupList",groupsgetGroupMembershipgroupListCommandParameterInfo); - + InteractionInfo groupsgetGroupMembershipInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .getGroupMembership((ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback , (ArrayList) commandArguments.get("groupList") - + ); }, () -> new DelegatedGetGroupMembershipResponseCallback(), @@ -5860,7 +5860,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .removeAllGroups((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5870,14 +5870,14 @@ public Map> getCommandMap() { Map groupsremoveGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsremoveGroupCommandParams.put("groupId",groupsremoveGroupgroupIdCommandParameterInfo); - + InteractionInfo groupsremoveGroupInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .removeGroup((ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedRemoveGroupResponseCallback(), @@ -5887,14 +5887,14 @@ public Map> getCommandMap() { Map groupsviewGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsviewGroupCommandParams.put("groupId",groupsviewGroupgroupIdCommandParameterInfo); - + InteractionInfo groupsviewGroupInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .viewGroup((ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedViewGroupResponseCallback(), @@ -5906,14 +5906,14 @@ public Map> getCommandMap() { Map identifyidentifyCommandParams = new LinkedHashMap(); CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("identifyTime", Integer.class); identifyidentifyCommandParams.put("identifyTime",identifyidentifyidentifyTimeCommandParameterInfo); - + InteractionInfo identifyidentifyInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .identify((DefaultClusterCallback) callback , (Integer) commandArguments.get("identifyTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5925,7 +5925,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .identifyQuery((ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback - + ); }, () -> new DelegatedIdentifyQueryResponseCallback(), @@ -5935,10 +5935,10 @@ public Map> getCommandMap() { Map identifytriggerEffectCommandParams = new LinkedHashMap(); CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = new CommandParameterInfo("effectIdentifier", Integer.class); identifytriggerEffectCommandParams.put("effectIdentifier",identifytriggerEffecteffectIdentifierCommandParameterInfo); - + CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); identifytriggerEffectCommandParams.put("effectVariant",identifytriggerEffecteffectVariantCommandParameterInfo); - + InteractionInfo identifytriggerEffectInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) @@ -5947,7 +5947,7 @@ public Map> getCommandMap() { commandArguments.get("effectIdentifier") , (Integer) commandArguments.get("effectVariant") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5961,14 +5961,14 @@ public Map> getCommandMap() { Map keypadInputsendKeyRequestCommandParams = new LinkedHashMap(); CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = new CommandParameterInfo("keyCode", Integer.class); keypadInputsendKeyRequestCommandParams.put("keyCode",keypadInputsendKeyRequestkeyCodeCommandParameterInfo); - + InteractionInfo keypadInputsendKeyRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.KeypadInputCluster) cluster) .sendKeyRequest((ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback , (Integer) commandArguments.get("keyCode") - + ); }, () -> new DelegatedSendKeyResponseCallback(), @@ -5980,16 +5980,16 @@ public Map> getCommandMap() { Map levelControlmoveCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); levelControlmoveCommandParams.put("moveMode",levelControlmovemoveModeCommandParameterInfo); - + CommandParameterInfo levelControlmoverateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); levelControlmoveCommandParams.put("rate",levelControlmoverateCommandParameterInfo); - + CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlmoveCommandParams.put("optionMask",levelControlmoveoptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlmoveCommandParams.put("optionOverride",levelControlmoveoptionOverrideCommandParameterInfo); - + InteractionInfo levelControlmoveInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6002,7 +6002,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6012,16 +6012,16 @@ public Map> getCommandMap() { Map levelControlmoveToLevelCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); levelControlmoveToLevelCommandParams.put("level",levelControlmoveToLevellevelCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlmoveToLevelCommandParams.put("transitionTime",levelControlmoveToLeveltransitionTimeCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlmoveToLevelCommandParams.put("optionMask",levelControlmoveToLeveloptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlmoveToLevelCommandParams.put("optionOverride",levelControlmoveToLeveloptionOverrideCommandParameterInfo); - + InteractionInfo levelControlmoveToLevelInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6034,7 +6034,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6044,10 +6044,10 @@ public Map> getCommandMap() { Map levelControlmoveToLevelWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); levelControlmoveToLevelWithOnOffCommandParams.put("level",levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlmoveToLevelWithOnOffCommandParams.put("transitionTime",levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); - + InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6056,7 +6056,7 @@ public Map> getCommandMap() { commandArguments.get("level") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6066,10 +6066,10 @@ public Map> getCommandMap() { Map levelControlmoveWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); levelControlmoveWithOnOffCommandParams.put("moveMode",levelControlmoveWithOnOffmoveModeCommandParameterInfo); - + CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); levelControlmoveWithOnOffCommandParams.put("rate",levelControlmoveWithOnOffrateCommandParameterInfo); - + InteractionInfo levelControlmoveWithOnOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6078,7 +6078,7 @@ public Map> getCommandMap() { commandArguments.get("moveMode") , (Integer) commandArguments.get("rate") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6088,19 +6088,19 @@ public Map> getCommandMap() { Map levelControlstepCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstepstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); levelControlstepCommandParams.put("stepMode",levelControlstepstepModeCommandParameterInfo); - + CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); levelControlstepCommandParams.put("stepSize",levelControlstepstepSizeCommandParameterInfo); - + CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlstepCommandParams.put("transitionTime",levelControlsteptransitionTimeCommandParameterInfo); - + CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlstepCommandParams.put("optionMask",levelControlstepoptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlstepCommandParams.put("optionOverride",levelControlstepoptionOverrideCommandParameterInfo); - + InteractionInfo levelControlstepInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6115,7 +6115,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6125,13 +6125,13 @@ public Map> getCommandMap() { Map levelControlstepWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); levelControlstepWithOnOffCommandParams.put("stepMode",levelControlstepWithOnOffstepModeCommandParameterInfo); - + CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); levelControlstepWithOnOffCommandParams.put("stepSize",levelControlstepWithOnOffstepSizeCommandParameterInfo); - + CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlstepWithOnOffCommandParams.put("transitionTime",levelControlstepWithOnOfftransitionTimeCommandParameterInfo); - + InteractionInfo levelControlstepWithOnOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6142,7 +6142,7 @@ public Map> getCommandMap() { commandArguments.get("stepSize") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6152,10 +6152,10 @@ public Map> getCommandMap() { Map levelControlstopCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlstopCommandParams.put("optionMask",levelControlstopoptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlstopCommandParams.put("optionOverride",levelControlstopoptionOverrideCommandParameterInfo); - + InteractionInfo levelControlstopInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6164,7 +6164,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6176,7 +6176,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .stopWithOnOff((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6192,7 +6192,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.LowPowerCluster) cluster) .sleep((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6206,7 +6206,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .hideInputStatusRequest((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6216,10 +6216,10 @@ public Map> getCommandMap() { Map mediaInputrenameInputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); mediaInputrenameInputRequestCommandParams.put("index",mediaInputrenameInputRequestindexCommandParameterInfo); - + CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); mediaInputrenameInputRequestCommandParams.put("name",mediaInputrenameInputRequestnameCommandParameterInfo); - + InteractionInfo mediaInputrenameInputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) @@ -6228,7 +6228,7 @@ public Map> getCommandMap() { commandArguments.get("index") , (String) commandArguments.get("name") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6238,14 +6238,14 @@ public Map> getCommandMap() { Map mediaInputselectInputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); mediaInputselectInputRequestCommandParams.put("index",mediaInputselectInputRequestindexCommandParameterInfo); - + InteractionInfo mediaInputselectInputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .selectInputRequest((DefaultClusterCallback) callback , (Integer) commandArguments.get("index") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6257,7 +6257,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .showInputStatusRequest((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6271,7 +6271,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .fastForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6283,7 +6283,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .nextRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6295,7 +6295,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .pauseRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6307,7 +6307,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .playRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6319,7 +6319,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .previousRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6331,7 +6331,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .rewindRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6341,14 +6341,14 @@ public Map> getCommandMap() { Map mediaPlaybackseekRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = new CommandParameterInfo("position", Long.class); mediaPlaybackseekRequestCommandParams.put("position",mediaPlaybackseekRequestpositionCommandParameterInfo); - + InteractionInfo mediaPlaybackseekRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .seekRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback , (Long) commandArguments.get("position") - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6358,14 +6358,14 @@ public Map> getCommandMap() { Map mediaPlaybackskipBackwardRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); mediaPlaybackskipBackwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); - + InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .skipBackwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback , (Long) commandArguments.get("deltaPositionMilliseconds") - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6375,14 +6375,14 @@ public Map> getCommandMap() { Map mediaPlaybackskipForwardRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); mediaPlaybackskipForwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); - + InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .skipForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback , (Long) commandArguments.get("deltaPositionMilliseconds") - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6394,7 +6394,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .startOverRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6406,7 +6406,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .stopRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6418,14 +6418,14 @@ public Map> getCommandMap() { Map modeSelectchangeToModeCommandParams = new LinkedHashMap(); CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = new CommandParameterInfo("newMode", Integer.class); modeSelectchangeToModeCommandParams.put("newMode",modeSelectchangeToModenewModeCommandParameterInfo); - + InteractionInfo modeSelectchangeToModeInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ModeSelectCluster) cluster) .changeToMode((DefaultClusterCallback) callback , (Integer) commandArguments.get("newMode") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6437,10 +6437,10 @@ public Map> getCommandMap() { Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = new CommandParameterInfo("operationalDataset", byte[].class); networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("operationalDataset",networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); - + CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6449,7 +6449,7 @@ public Map> getCommandMap() { commandArguments.get("operationalDataset") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6459,13 +6459,13 @@ public Map> getCommandMap() { Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("ssid",networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); - + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = new CommandParameterInfo("credentials", byte[].class); networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("credentials",networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); - + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6476,7 +6476,7 @@ public Map> getCommandMap() { commandArguments.get("credentials") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6486,10 +6486,10 @@ public Map> getCommandMap() { Map networkCommissioningconnectNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); networkCommissioningconnectNetworkCommandParams.put("networkID",networkCommissioningconnectNetworknetworkIDCommandParameterInfo); - + CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningconnectNetworkCommandParams.put("breadcrumb",networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningconnectNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6498,7 +6498,7 @@ public Map> getCommandMap() { commandArguments.get("networkID") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedConnectNetworkResponseCallback(), @@ -6508,10 +6508,10 @@ public Map> getCommandMap() { Map networkCommissioningremoveNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); networkCommissioningremoveNetworkCommandParams.put("networkID",networkCommissioningremoveNetworknetworkIDCommandParameterInfo); - + CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningremoveNetworkCommandParams.put("breadcrumb",networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningremoveNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6520,7 +6520,7 @@ public Map> getCommandMap() { commandArguments.get("networkID") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6530,13 +6530,13 @@ public Map> getCommandMap() { Map networkCommissioningreorderNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); networkCommissioningreorderNetworkCommandParams.put("networkID",networkCommissioningreorderNetworknetworkIDCommandParameterInfo); - + CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = new CommandParameterInfo("networkIndex", Integer.class); networkCommissioningreorderNetworkCommandParams.put("networkIndex",networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); - + CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningreorderNetworkCommandParams.put("breadcrumb",networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningreorderNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6547,7 +6547,7 @@ public Map> getCommandMap() { commandArguments.get("networkIndex") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6557,10 +6557,10 @@ public Map> getCommandMap() { Map networkCommissioningscanNetworksCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); networkCommissioningscanNetworksCommandParams.put("ssid",networkCommissioningscanNetworksssidCommandParameterInfo); - + CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningscanNetworksCommandParams.put("breadcrumb",networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningscanNetworksInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6569,7 +6569,7 @@ public Map> getCommandMap() { commandArguments.get("ssid") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedScanNetworksResponseCallback(), @@ -6581,10 +6581,10 @@ public Map> getCommandMap() { Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("updateToken",otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = new CommandParameterInfo("newVersion", Long.class); otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("newVersion",otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) @@ -6593,7 +6593,7 @@ public Map> getCommandMap() { commandArguments.get("updateToken") , (Long) commandArguments.get("newVersion") - + ); }, () -> new DelegatedApplyUpdateResponseCallback(), @@ -6603,10 +6603,10 @@ public Map> getCommandMap() { Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("updateToken",otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("softwareVersion",otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) @@ -6615,7 +6615,7 @@ public Map> getCommandMap() { commandArguments.get("updateToken") , (Long) commandArguments.get("softwareVersion") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6625,28 +6625,28 @@ public Map> getCommandMap() { Map otaSoftwareUpdateProviderqueryImageCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("vendorId",otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = new CommandParameterInfo("productId", Integer.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("productId",otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("softwareVersion",otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = new CommandParameterInfo("protocolsSupported", ArrayList.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("protocolsSupported",otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = new CommandParameterInfo("hardwareVersion", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("hardwareVersion",otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = new CommandParameterInfo("location", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("location",otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = new CommandParameterInfo("requestorCanConsent", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("requestorCanConsent",otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = new CommandParameterInfo("metadataForProvider", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("metadataForProvider",otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) @@ -6667,7 +6667,7 @@ public Map> getCommandMap() { commandArguments.get("requestorCanConsent") , (Optional) commandArguments.get("metadataForProvider") - + ); }, () -> new DelegatedQueryImageResponseCallback(), @@ -6679,19 +6679,19 @@ public Map> getCommandMap() { Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = new CommandParameterInfo("providerNodeId", Long.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("providerNodeId",otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("vendorId",otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = new CommandParameterInfo("announcementReason", Integer.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("announcementReason",otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = new CommandParameterInfo("metadataForNode", Optional.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("metadataForNode",otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = new CommandParameterInfo("endpoint", Integer.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("endpoint",otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) @@ -6706,7 +6706,7 @@ public Map> getCommandMap() { commandArguments.get("metadataForNode") , (Integer) commandArguments.get("endpoint") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6722,7 +6722,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .off((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6732,10 +6732,10 @@ public Map> getCommandMap() { Map onOffoffWithEffectCommandParams = new LinkedHashMap(); CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = new CommandParameterInfo("effectId", Integer.class); onOffoffWithEffectCommandParams.put("effectId",onOffoffWithEffecteffectIdCommandParameterInfo); - + CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); onOffoffWithEffectCommandParams.put("effectVariant",onOffoffWithEffecteffectVariantCommandParameterInfo); - + InteractionInfo onOffoffWithEffectInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) @@ -6744,7 +6744,7 @@ public Map> getCommandMap() { commandArguments.get("effectId") , (Integer) commandArguments.get("effectVariant") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6756,7 +6756,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .on((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6768,7 +6768,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .onWithRecallGlobalScene((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6778,13 +6778,13 @@ public Map> getCommandMap() { Map onOffonWithTimedOffCommandParams = new LinkedHashMap(); CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = new CommandParameterInfo("onOffControl", Integer.class); onOffonWithTimedOffCommandParams.put("onOffControl",onOffonWithTimedOffonOffControlCommandParameterInfo); - + CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = new CommandParameterInfo("onTime", Integer.class); onOffonWithTimedOffCommandParams.put("onTime",onOffonWithTimedOffonTimeCommandParameterInfo); - + CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("offWaitTime", Integer.class); onOffonWithTimedOffCommandParams.put("offWaitTime",onOffonWithTimedOffoffWaitTimeCommandParameterInfo); - + InteractionInfo onOffonWithTimedOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) @@ -6795,7 +6795,7 @@ public Map> getCommandMap() { commandArguments.get("onTime") , (Integer) commandArguments.get("offWaitTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6807,7 +6807,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .toggle((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6821,19 +6821,19 @@ public Map> getCommandMap() { Map operationalCredentialsaddNOCCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); operationalCredentialsaddNOCCommandParams.put("NOCValue",operationalCredentialsaddNOCNOCValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); operationalCredentialsaddNOCCommandParams.put("ICACValue",operationalCredentialsaddNOCICACValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = new CommandParameterInfo("IPKValue", byte[].class); operationalCredentialsaddNOCCommandParams.put("IPKValue",operationalCredentialsaddNOCIPKValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = new CommandParameterInfo("caseAdminNode", Long.class); operationalCredentialsaddNOCCommandParams.put("caseAdminNode",operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = new CommandParameterInfo("adminVendorId", Integer.class); operationalCredentialsaddNOCCommandParams.put("adminVendorId",operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); - + InteractionInfo operationalCredentialsaddNOCInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) @@ -6848,7 +6848,7 @@ public Map> getCommandMap() { commandArguments.get("caseAdminNode") , (Integer) commandArguments.get("adminVendorId") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -6858,14 +6858,14 @@ public Map> getCommandMap() { Map operationalCredentialsaddTrustedRootCertificateCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = new CommandParameterInfo("rootCertificate", byte[].class); operationalCredentialsaddTrustedRootCertificateCommandParams.put("rootCertificate",operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); - + InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .addTrustedRootCertificate((DefaultClusterCallback) callback , (byte[]) commandArguments.get("rootCertificate") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6875,14 +6875,14 @@ public Map> getCommandMap() { Map operationalCredentialsattestationRequestCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = new CommandParameterInfo("attestationNonce", byte[].class); operationalCredentialsattestationRequestCommandParams.put("attestationNonce",operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); - + InteractionInfo operationalCredentialsattestationRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .attestationRequest((ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) callback , (byte[]) commandArguments.get("attestationNonce") - + ); }, () -> new DelegatedAttestationResponseCallback(), @@ -6892,14 +6892,14 @@ public Map> getCommandMap() { Map operationalCredentialscertificateChainRequestCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = new CommandParameterInfo("certificateType", Integer.class); operationalCredentialscertificateChainRequestCommandParams.put("certificateType",operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); - + InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .certificateChainRequest((ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) callback , (Integer) commandArguments.get("certificateType") - + ); }, () -> new DelegatedCertificateChainResponseCallback(), @@ -6909,14 +6909,14 @@ public Map> getCommandMap() { Map operationalCredentialsopCSRRequestCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = new CommandParameterInfo("CSRNonce", byte[].class); operationalCredentialsopCSRRequestCommandParams.put("CSRNonce",operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); - + InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .opCSRRequest((ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback , (byte[]) commandArguments.get("CSRNonce") - + ); }, () -> new DelegatedOpCSRResponseCallback(), @@ -6926,14 +6926,14 @@ public Map> getCommandMap() { Map operationalCredentialsremoveFabricCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = new CommandParameterInfo("fabricIndex", Integer.class); operationalCredentialsremoveFabricCommandParams.put("fabricIndex",operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); - + InteractionInfo operationalCredentialsremoveFabricInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .removeFabric((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback , (Integer) commandArguments.get("fabricIndex") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -6943,14 +6943,14 @@ public Map> getCommandMap() { Map operationalCredentialsremoveTrustedRootCertificateCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = new CommandParameterInfo("trustedRootIdentifier", byte[].class); operationalCredentialsremoveTrustedRootCertificateCommandParams.put("trustedRootIdentifier",operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); - + InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .removeTrustedRootCertificate((DefaultClusterCallback) callback , (byte[]) commandArguments.get("trustedRootIdentifier") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6960,14 +6960,14 @@ public Map> getCommandMap() { Map operationalCredentialsupdateFabricLabelCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = new CommandParameterInfo("label", String.class); operationalCredentialsupdateFabricLabelCommandParams.put("label",operationalCredentialsupdateFabricLabellabelCommandParameterInfo); - + InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .updateFabricLabel((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback , (String) commandArguments.get("label") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -6977,10 +6977,10 @@ public Map> getCommandMap() { Map operationalCredentialsupdateNOCCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); operationalCredentialsupdateNOCCommandParams.put("NOCValue",operationalCredentialsupdateNOCNOCValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); operationalCredentialsupdateNOCCommandParams.put("ICACValue",operationalCredentialsupdateNOCICACValueCommandParameterInfo); - + InteractionInfo operationalCredentialsupdateNOCInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) @@ -6989,7 +6989,7 @@ public Map> getCommandMap() { commandArguments.get("NOCValue") , (Optional) commandArguments.get("ICACValue") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -7011,16 +7011,16 @@ public Map> getCommandMap() { Map scenesaddSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesaddSceneCommandParams.put("groupId",scenesaddScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesaddSceneCommandParams.put("sceneId",scenesaddScenesceneIdCommandParameterInfo); - + CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); scenesaddSceneCommandParams.put("transitionTime",scenesaddScenetransitionTimeCommandParameterInfo); - + CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = new CommandParameterInfo("sceneName", String.class); scenesaddSceneCommandParams.put("sceneName",scenesaddScenesceneNameCommandParameterInfo); - + InteractionInfo scenesaddSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7035,7 +7035,7 @@ public Map> getCommandMap() { commandArguments.get("sceneName") , (ArrayList) commandArguments.get("extensionFieldSets") - + ); }, () -> new DelegatedAddSceneResponseCallback(), @@ -7045,14 +7045,14 @@ public Map> getCommandMap() { Map scenesgetSceneMembershipCommandParams = new LinkedHashMap(); CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesgetSceneMembershipCommandParams.put("groupId",scenesgetSceneMembershipgroupIdCommandParameterInfo); - + InteractionInfo scenesgetSceneMembershipInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .getSceneMembership((ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedGetSceneMembershipResponseCallback(), @@ -7062,13 +7062,13 @@ public Map> getCommandMap() { Map scenesrecallSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesrecallSceneCommandParams.put("groupId",scenesrecallScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesrecallSceneCommandParams.put("sceneId",scenesrecallScenesceneIdCommandParameterInfo); - + CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); scenesrecallSceneCommandParams.put("transitionTime",scenesrecallScenetransitionTimeCommandParameterInfo); - + InteractionInfo scenesrecallSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7079,7 +7079,7 @@ public Map> getCommandMap() { commandArguments.get("sceneId") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7089,14 +7089,14 @@ public Map> getCommandMap() { Map scenesremoveAllScenesCommandParams = new LinkedHashMap(); CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesremoveAllScenesCommandParams.put("groupId",scenesremoveAllScenesgroupIdCommandParameterInfo); - + InteractionInfo scenesremoveAllScenesInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .removeAllScenes((ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedRemoveAllScenesResponseCallback(), @@ -7106,10 +7106,10 @@ public Map> getCommandMap() { Map scenesremoveSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesremoveSceneCommandParams.put("groupId",scenesremoveScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesremoveSceneCommandParams.put("sceneId",scenesremoveScenesceneIdCommandParameterInfo); - + InteractionInfo scenesremoveSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7118,7 +7118,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (Integer) commandArguments.get("sceneId") - + ); }, () -> new DelegatedRemoveSceneResponseCallback(), @@ -7128,10 +7128,10 @@ public Map> getCommandMap() { Map scenesstoreSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesstoreSceneCommandParams.put("groupId",scenesstoreScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesstoreSceneCommandParams.put("sceneId",scenesstoreScenesceneIdCommandParameterInfo); - + InteractionInfo scenesstoreSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7140,7 +7140,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (Integer) commandArguments.get("sceneId") - + ); }, () -> new DelegatedStoreSceneResponseCallback(), @@ -7150,10 +7150,10 @@ public Map> getCommandMap() { Map scenesviewSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesviewSceneCommandParams.put("groupId",scenesviewScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesviewSceneCommandParams.put("sceneId",scenesviewScenesceneIdCommandParameterInfo); - + InteractionInfo scenesviewSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7162,7 +7162,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (Integer) commandArguments.get("sceneId") - + ); }, () -> new DelegatedViewSceneResponseCallback(), @@ -7176,7 +7176,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.SoftwareDiagnosticsCluster) cluster) .resetWatermarks((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7190,10 +7190,10 @@ public Map> getCommandMap() { Map targetNavigatornavigateTargetRequestCommandParams = new LinkedHashMap(); CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = new CommandParameterInfo("target", Integer.class); targetNavigatornavigateTargetRequestCommandParams.put("target",targetNavigatornavigateTargetRequesttargetCommandParameterInfo); - + CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); targetNavigatornavigateTargetRequestCommandParams.put("data",targetNavigatornavigateTargetRequestdataCommandParameterInfo); - + InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TargetNavigatorCluster) cluster) @@ -7202,7 +7202,7 @@ public Map> getCommandMap() { commandArguments.get("target") , (String) commandArguments.get("data") - + ); }, () -> new DelegatedNavigateTargetResponseCallback(), @@ -7220,7 +7220,7 @@ public Map> getCommandMap() { .simpleStructEchoRequest((ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback , (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1") - + ); }, () -> new DelegatedSimpleStructResponseCallback(), @@ -7232,7 +7232,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .test((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7242,10 +7242,10 @@ public Map> getCommandMap() { Map testClustertestAddArgumentsCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); testClustertestAddArgumentsCommandParams.put("arg1",testClustertestAddArgumentsarg1CommandParameterInfo); - + CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); testClustertestAddArgumentsCommandParams.put("arg2",testClustertestAddArgumentsarg2CommandParameterInfo); - + InteractionInfo testClustertestAddArgumentsInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) @@ -7254,7 +7254,7 @@ public Map> getCommandMap() { commandArguments.get("arg1") , (Integer) commandArguments.get("arg2") - + ); }, () -> new DelegatedTestAddArgumentsResponseCallback(), @@ -7264,13 +7264,13 @@ public Map> getCommandMap() { Map testClustertestEmitTestEventRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); testClustertestEmitTestEventRequestCommandParams.put("arg1",testClustertestEmitTestEventRequestarg1CommandParameterInfo); - + CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); testClustertestEmitTestEventRequestCommandParams.put("arg2",testClustertestEmitTestEventRequestarg2CommandParameterInfo); - + CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = new CommandParameterInfo("arg3", Boolean.class); testClustertestEmitTestEventRequestCommandParams.put("arg3",testClustertestEmitTestEventRequestarg3CommandParameterInfo); - + InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) @@ -7281,7 +7281,7 @@ public Map> getCommandMap() { commandArguments.get("arg2") , (Boolean) commandArguments.get("arg3") - + ); }, () -> new DelegatedTestEmitTestEventResponseCallback(), @@ -7291,10 +7291,10 @@ public Map> getCommandMap() { Map testClustertestEnumsRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); testClustertestEnumsRequestCommandParams.put("arg1",testClustertestEnumsRequestarg1CommandParameterInfo); - + CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); testClustertestEnumsRequestCommandParams.put("arg2",testClustertestEnumsRequestarg2CommandParameterInfo); - + InteractionInfo testClustertestEnumsRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) @@ -7303,7 +7303,7 @@ public Map> getCommandMap() { commandArguments.get("arg1") , (Integer) commandArguments.get("arg2") - + ); }, () -> new DelegatedTestEnumsResponseCallback(), @@ -7313,14 +7313,14 @@ public Map> getCommandMap() { Map testClustertestListInt8UArgumentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); testClustertestListInt8UArgumentRequestCommandParams.put("arg1",testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testListInt8UArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7330,14 +7330,14 @@ public Map> getCommandMap() { Map testClustertestListInt8UReverseRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); testClustertestListInt8UReverseRequestCommandParams.put("arg1",testClustertestListInt8UReverseRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testListInt8UReverseRequest((ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedTestListInt8UReverseResponseCallback(), @@ -7351,7 +7351,7 @@ public Map> getCommandMap() { .testListNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7365,7 +7365,7 @@ public Map> getCommandMap() { .testListStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7379,7 +7379,7 @@ public Map> getCommandMap() { .testNestedStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ChipStructs.TestClusterClusterNestedStruct) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7393,7 +7393,7 @@ public Map> getCommandMap() { .testNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ChipStructs.TestClusterClusterNestedStructList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7405,7 +7405,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testNotHandled((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7415,14 +7415,14 @@ public Map> getCommandMap() { Map testClustertestNullableOptionalRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); testClustertestNullableOptionalRequestCommandParams.put("arg1",testClustertestNullableOptionalRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testNullableOptionalRequest((ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) callback , (Optional) commandArguments.get("arg1") - + ); }, () -> new DelegatedTestNullableOptionalResponseCallback(), @@ -7432,14 +7432,14 @@ public Map> getCommandMap() { Map testClustertestSimpleOptionalArgumentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); testClustertestSimpleOptionalArgumentRequestCommandParams.put("arg1",testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testSimpleOptionalArgumentRequest((DefaultClusterCallback) callback , (Optional) commandArguments.get("arg1") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7451,7 +7451,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testSpecific((ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback - + ); }, () -> new DelegatedTestSpecificResponseCallback(), @@ -7465,7 +7465,7 @@ public Map> getCommandMap() { .testStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7477,7 +7477,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testUnknownCommand((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7503,7 +7503,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .clearWeeklySchedule((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7515,7 +7515,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .getRelayStatusLog((ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback - + ); }, () -> new DelegatedGetRelayStatusLogResponseCallback(), @@ -7525,10 +7525,10 @@ public Map> getCommandMap() { Map thermostatgetWeeklyScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = new CommandParameterInfo("daysToReturn", Integer.class); thermostatgetWeeklyScheduleCommandParams.put("daysToReturn",thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); - + CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = new CommandParameterInfo("modeToReturn", Integer.class); thermostatgetWeeklyScheduleCommandParams.put("modeToReturn",thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); - + InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) @@ -7537,7 +7537,7 @@ public Map> getCommandMap() { commandArguments.get("daysToReturn") , (Integer) commandArguments.get("modeToReturn") - + ); }, () -> new DelegatedGetWeeklyScheduleResponseCallback(), @@ -7547,16 +7547,16 @@ public Map> getCommandMap() { Map thermostatsetWeeklyScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); thermostatsetWeeklyScheduleCommandParams.put("numberOfTransitionsForSequence",thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); - + CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = new CommandParameterInfo("dayOfWeekForSequence", Integer.class); thermostatsetWeeklyScheduleCommandParams.put("dayOfWeekForSequence",thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); - + CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = new CommandParameterInfo("modeForSequence", Integer.class); thermostatsetWeeklyScheduleCommandParams.put("modeForSequence",thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); - + CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = new CommandParameterInfo("payload", ArrayList.class); thermostatsetWeeklyScheduleCommandParams.put("payload",thermostatsetWeeklySchedulepayloadCommandParameterInfo); - + InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) @@ -7569,7 +7569,7 @@ public Map> getCommandMap() { commandArguments.get("modeForSequence") , (ArrayList) commandArguments.get("payload") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7579,10 +7579,10 @@ public Map> getCommandMap() { Map thermostatsetpointRaiseLowerCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = new CommandParameterInfo("mode", Integer.class); thermostatsetpointRaiseLowerCommandParams.put("mode",thermostatsetpointRaiseLowermodeCommandParameterInfo); - + CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = new CommandParameterInfo("amount", Integer.class); thermostatsetpointRaiseLowerCommandParams.put("amount",thermostatsetpointRaiseLoweramountCommandParameterInfo); - + InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) @@ -7591,7 +7591,7 @@ public Map> getCommandMap() { commandArguments.get("mode") , (Integer) commandArguments.get("amount") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7607,7 +7607,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .resetCounts((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7629,7 +7629,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .resetCounts((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7643,7 +7643,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .downOrClose((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7653,10 +7653,10 @@ public Map> getCommandMap() { Map windowCoveringgoToLiftPercentageCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = new CommandParameterInfo("liftPercentageValue", Integer.class); windowCoveringgoToLiftPercentageCommandParams.put("liftPercentageValue",windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); - + CommandParameterInfo windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = new CommandParameterInfo("liftPercent100thsValue", Integer.class); windowCoveringgoToLiftPercentageCommandParams.put("liftPercent100thsValue",windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) @@ -7665,7 +7665,7 @@ public Map> getCommandMap() { commandArguments.get("liftPercentageValue") , (Integer) commandArguments.get("liftPercent100thsValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7675,14 +7675,14 @@ public Map> getCommandMap() { Map windowCoveringgoToLiftValueCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = new CommandParameterInfo("liftValue", Integer.class); windowCoveringgoToLiftValueCommandParams.put("liftValue",windowCoveringgoToLiftValueliftValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToLiftValueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .goToLiftValue((DefaultClusterCallback) callback , (Integer) commandArguments.get("liftValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7692,10 +7692,10 @@ public Map> getCommandMap() { Map windowCoveringgoToTiltPercentageCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = new CommandParameterInfo("tiltPercentageValue", Integer.class); windowCoveringgoToTiltPercentageCommandParams.put("tiltPercentageValue",windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); - + CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = new CommandParameterInfo("tiltPercent100thsValue", Integer.class); windowCoveringgoToTiltPercentageCommandParams.put("tiltPercent100thsValue",windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) @@ -7704,7 +7704,7 @@ public Map> getCommandMap() { commandArguments.get("tiltPercentageValue") , (Integer) commandArguments.get("tiltPercent100thsValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7714,14 +7714,14 @@ public Map> getCommandMap() { Map windowCoveringgoToTiltValueCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = new CommandParameterInfo("tiltValue", Integer.class); windowCoveringgoToTiltValueCommandParams.put("tiltValue",windowCoveringgoToTiltValuetiltValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToTiltValueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .goToTiltValue((DefaultClusterCallback) callback , (Integer) commandArguments.get("tiltValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7733,7 +7733,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .stopMotion((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7745,7 +7745,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .upOrOpen((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7757,4 +7757,3 @@ public Map> getCommandMap() { } } - diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java index 48ec9330a3b2f2..e433d2ce7db37d 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java @@ -8070,4 +8070,3 @@ public Map> getReadAttributeMap() { return readAttributeMap; } } - diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java index a70c5b71a4a9de..e701c60d01ca31 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java @@ -53,7 +53,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -69,7 +69,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -85,7 +85,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -103,7 +103,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -119,7 +119,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -147,7 +147,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -163,7 +163,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -179,7 +179,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -195,7 +195,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -211,7 +211,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -227,7 +227,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -243,7 +243,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -259,7 +259,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -275,7 +275,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -291,7 +291,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -307,7 +307,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -323,7 +323,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -339,7 +339,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -357,7 +357,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -379,7 +379,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -395,7 +395,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -411,7 +411,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -427,7 +427,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -443,7 +443,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -459,7 +459,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -475,7 +475,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -501,7 +501,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -525,7 +525,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -547,7 +547,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -563,7 +563,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -579,7 +579,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -595,7 +595,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -611,7 +611,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -627,7 +627,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -643,7 +643,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -661,7 +661,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -685,7 +685,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -703,7 +703,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -727,7 +727,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -743,7 +743,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -759,7 +759,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -777,7 +777,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -803,7 +803,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -819,7 +819,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -835,7 +835,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -851,7 +851,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -881,7 +881,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -897,7 +897,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -913,7 +913,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -929,7 +929,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -945,7 +945,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -961,7 +961,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -977,7 +977,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -993,7 +993,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1009,7 +1009,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1025,7 +1025,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1041,7 +1041,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1057,7 +1057,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1073,7 +1073,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1089,7 +1089,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1105,7 +1105,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1121,7 +1121,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1137,7 +1137,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1153,7 +1153,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1169,7 +1169,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1185,7 +1185,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1201,7 +1201,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1217,7 +1217,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1233,7 +1233,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1249,7 +1249,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Float) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1265,7 +1265,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Double) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1281,7 +1281,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1297,7 +1297,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1313,7 +1313,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1329,7 +1329,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1345,7 +1345,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1361,7 +1361,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1377,7 +1377,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1393,7 +1393,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1409,7 +1409,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1425,7 +1425,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1441,7 +1441,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1457,7 +1457,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1489,7 +1489,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1505,7 +1505,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1521,7 +1521,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1537,7 +1537,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1553,7 +1553,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1569,7 +1569,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1585,7 +1585,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1601,7 +1601,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1617,7 +1617,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1633,7 +1633,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1649,7 +1649,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1665,7 +1665,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1681,7 +1681,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1697,7 +1697,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1713,7 +1713,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1729,7 +1729,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1745,7 +1745,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1761,7 +1761,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1777,7 +1777,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1793,7 +1793,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1809,7 +1809,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1825,7 +1825,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1841,7 +1841,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1857,7 +1857,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1873,7 +1873,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1889,7 +1889,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1905,7 +1905,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Float) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1921,7 +1921,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Double) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1937,7 +1937,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1953,7 +1953,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1969,7 +1969,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1985,7 +1985,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2001,7 +2001,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2017,7 +2017,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2033,7 +2033,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2051,7 +2051,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2067,7 +2067,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2083,7 +2083,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2099,7 +2099,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2115,7 +2115,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2131,7 +2131,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2147,7 +2147,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2163,7 +2163,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2179,7 +2179,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2197,7 +2197,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2213,7 +2213,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2229,7 +2229,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2249,7 +2249,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2265,7 +2265,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2283,7 +2283,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2307,7 +2307,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2318,4 +2318,3 @@ public Map> getWriteAttributeMap() { return writeAttributeMap; } } - From ca995b0143a7e2074ca45b8430a6f3feec8d9e2c Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Mon, 31 Jan 2022 17:23:13 +0000 Subject: [PATCH 07/14] Restyled by google-java-format --- .../chip/devicecontroller/ChipClusters.java | 23133 ++++++++-------- .../chip/devicecontroller/ChipStructs.java | 4075 ++- .../devicecontroller/ClusterInfoMapping.java | 16452 ++++++----- .../devicecontroller/ClusterReadMapping.java | 16098 +++++------ .../devicecontroller/ClusterWriteMapping.java | 4746 ++-- 5 files changed, 33661 insertions(+), 30843 deletions(-) diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index 84244edbcb62c1..5d633d4dab05af 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -21,7 +21,6 @@ import androidx.annotation.Nullable; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; import java.util.Optional; @@ -29,54 +28,69 @@ public class ChipClusters { public interface DefaultClusterCallback { void onSuccess(); + void onError(Exception error); } public interface CharStringAttributeCallback { /** Indicates a successful read for a CHAR_STRING attribute. */ void onSuccess(String value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface OctetStringAttributeCallback { /** Indicates a successful read for an OCTET_STRING attribute. */ void onSuccess(byte[] value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface IntegerAttributeCallback { void onSuccess(int value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface LongAttributeCallback { void onSuccess(long value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface BooleanAttributeCallback { void onSuccess(boolean value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface FloatAttributeCallback { void onSuccess(float value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface DoubleAttributeCallback { void onSuccess(double value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } - public static abstract class BaseChipCluster { + public abstract static class BaseChipCluster { protected long chipClusterPtr; public BaseChipCluster(long devicePtr, int endpointId) { @@ -108,115 +122,129 @@ public AccessControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AclAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ExtensionAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AclAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ExtensionAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAclAttribute( - AclAttributeCallback callback - ) { + public void readAclAttribute(AclAttributeCallback callback) { readAclAttribute(chipClusterPtr, callback); } - public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeAclAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeAclAttribute(chipClusterPtr, callback, value, null); } - public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeAclAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeAclAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeAclAttribute( - AclAttributeCallback callback - , - int minInterval, int maxInterval) { + AclAttributeCallback callback, int minInterval, int maxInterval) { subscribeAclAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readExtensionAttribute( - ExtensionAttributeCallback callback - ) { + public void readExtensionAttribute(ExtensionAttributeCallback callback) { readExtensionAttribute(chipClusterPtr, callback); } - public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeExtensionAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeExtensionAttribute(chipClusterPtr, callback, value, null); } - public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeExtensionAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeExtensionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeExtensionAttribute( - ExtensionAttributeCallback callback - , - int minInterval, int maxInterval) { + ExtensionAttributeCallback callback, int minInterval, int maxInterval) { subscribeExtensionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAclAttribute(long chipClusterPtr, - AclAttributeCallback callback - ); - - private native void writeAclAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeAclAttribute(long chipClusterPtr, - AclAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readExtensionAttribute(long chipClusterPtr, - ExtensionAttributeCallback callback - ); - - private native void writeExtensionAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeExtensionAttribute(long chipClusterPtr, - ExtensionAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readAclAttribute(long chipClusterPtr, AclAttributeCallback callback); + + private native void writeAclAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeAclAttribute( + long chipClusterPtr, AclAttributeCallback callback, int minInterval, int maxInterval); + + private native void readExtensionAttribute( + long chipClusterPtr, ExtensionAttributeCallback callback); + + private native void writeExtensionAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeExtensionAttribute( + long chipClusterPtr, ExtensionAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class AccountLoginCluster extends BaseChipCluster { @@ -229,85 +257,90 @@ public AccountLoginCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - - public void getSetupPINRequest(GetSetupPINResponseCallback callback - , String tempAccountIdentifier - , int timedInvokeTimeoutMs) { + public void getSetupPINRequest( + GetSetupPINResponseCallback callback, + String tempAccountIdentifier, + int timedInvokeTimeoutMs) { getSetupPINRequest(chipClusterPtr, callback, tempAccountIdentifier, timedInvokeTimeoutMs); } - - public void loginRequest(DefaultClusterCallback callback - , String tempAccountIdentifier, String setupPIN - , int timedInvokeTimeoutMs) { + public void loginRequest( + DefaultClusterCallback callback, + String tempAccountIdentifier, + String setupPIN, + int timedInvokeTimeoutMs) { loginRequest(chipClusterPtr, callback, tempAccountIdentifier, setupPIN, timedInvokeTimeoutMs); } + public void logoutRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - public void logoutRequest(DefaultClusterCallback callback - - , int timedInvokeTimeoutMs) { logoutRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void getSetupPINRequest(long chipClusterPtr, GetSetupPINResponseCallback Callback - , String tempAccountIdentifier - , @Nullable Integer timedInvokeTimeoutMs); - private native void loginRequest(long chipClusterPtr, DefaultClusterCallback Callback - , String tempAccountIdentifier, String setupPIN - , @Nullable Integer timedInvokeTimeoutMs); - private native void logoutRequest(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void getSetupPINRequest( + long chipClusterPtr, + GetSetupPINResponseCallback Callback, + String tempAccountIdentifier, + @Nullable Integer timedInvokeTimeoutMs); + + private native void loginRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + String tempAccountIdentifier, + String setupPIN, + @Nullable Integer timedInvokeTimeoutMs); + + private native void logoutRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + public interface GetSetupPINResponseCallback { void onSuccess(String setupPIN); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 AdministratorCommissioningCluster extends BaseChipCluster { @@ -320,141 +353,156 @@ public AdministratorCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); + public void openBasicCommissioningWindow( + DefaultClusterCallback callback, Integer commissioningTimeout, int timedInvokeTimeoutMs) { + openBasicCommissioningWindow( + chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs); + } + + public void openCommissioningWindow( + DefaultClusterCallback callback, + Integer commissioningTimeout, + byte[] PAKEVerifier, + Integer discriminator, + Long iterations, + byte[] salt, + Integer passcodeID, + int timedInvokeTimeoutMs) { + openCommissioningWindow( + chipClusterPtr, + callback, + commissioningTimeout, + PAKEVerifier, + discriminator, + iterations, + salt, + passcodeID, + timedInvokeTimeoutMs); + } + + public void revokeCommissioning(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - public void openBasicCommissioningWindow(DefaultClusterCallback callback - , Integer commissioningTimeout - , int timedInvokeTimeoutMs) { - openBasicCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs); + revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void openBasicCommissioningWindow( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer commissioningTimeout, + @Nullable Integer timedInvokeTimeoutMs); - public void openCommissioningWindow(DefaultClusterCallback callback - , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID - , int timedInvokeTimeoutMs) { - openCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, PAKEVerifier, discriminator, iterations, salt, passcodeID, timedInvokeTimeoutMs); - } + private native void openCommissioningWindow( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer commissioningTimeout, + byte[] PAKEVerifier, + Integer discriminator, + Long iterations, + byte[] salt, + Integer passcodeID, + @Nullable Integer timedInvokeTimeoutMs); + private native void revokeCommissioning( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public void revokeCommissioning(DefaultClusterCallback callback + public interface AdminFabricIndexAttributeCallback { + void onSuccess(Integer value); - , int timedInvokeTimeoutMs) { - revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void openBasicCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback - , Integer commissioningTimeout - , @Nullable Integer timedInvokeTimeoutMs); - private native void openCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback - , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void revokeCommissioning(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AdminFabricIndexAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readWindowStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readWindowStatusAttribute(IntegerAttributeCallback callback) { readWindowStatusAttribute(chipClusterPtr, callback); } + public void subscribeWindowStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWindowStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAdminFabricIndexAttribute( - AdminFabricIndexAttributeCallback callback - ) { + public void readAdminFabricIndexAttribute(AdminFabricIndexAttributeCallback callback) { readAdminFabricIndexAttribute(chipClusterPtr, callback); } + public void subscribeAdminFabricIndexAttribute( - AdminFabricIndexAttributeCallback callback - , - int minInterval, int maxInterval) { + AdminFabricIndexAttributeCallback callback, int minInterval, int maxInterval) { subscribeAdminFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAdminVendorIdAttribute( - IntegerAttributeCallback callback - ) { + public void readAdminVendorIdAttribute(IntegerAttributeCallback callback) { readAdminVendorIdAttribute(chipClusterPtr, callback); } + public void subscribeAdminVendorIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAdminVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readWindowStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeWindowStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAdminFabricIndexAttribute(long chipClusterPtr, - AdminFabricIndexAttributeCallback callback - ); - private native void subscribeAdminFabricIndexAttribute(long chipClusterPtr, - AdminFabricIndexAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readAdminVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAdminVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readWindowStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeWindowStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAdminFabricIndexAttribute( + long chipClusterPtr, AdminFabricIndexAttributeCallback callback); + + private native void subscribeAdminFabricIndexAttribute( + long chipClusterPtr, + AdminFabricIndexAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readAdminVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAdminVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ApplicationBasicCluster extends BaseChipCluster { @@ -467,187 +515,171 @@ public ApplicationBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AllowedVendorListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AllowedVendorListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readVendorNameAttribute( - CharStringAttributeCallback callback - ) { + public void readVendorNameAttribute(CharStringAttributeCallback callback) { readVendorNameAttribute(chipClusterPtr, callback); } + public void subscribeVendorNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIdAttribute( - IntegerAttributeCallback callback - ) { + public void readVendorIdAttribute(IntegerAttributeCallback callback) { readVendorIdAttribute(chipClusterPtr, callback); } + public void subscribeVendorIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationNameAttribute( - CharStringAttributeCallback callback - ) { + public void readApplicationNameAttribute(CharStringAttributeCallback callback) { readApplicationNameAttribute(chipClusterPtr, callback); } + public void subscribeApplicationNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductIdAttribute( - IntegerAttributeCallback callback - ) { + public void readProductIdAttribute(IntegerAttributeCallback callback) { readProductIdAttribute(chipClusterPtr, callback); } + public void subscribeProductIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readApplicationStatusAttribute(IntegerAttributeCallback callback) { readApplicationStatusAttribute(chipClusterPtr, callback); } + public void subscribeApplicationStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationVersionAttribute( - CharStringAttributeCallback callback - ) { + public void readApplicationVersionAttribute(CharStringAttributeCallback callback) { readApplicationVersionAttribute(chipClusterPtr, callback); } + public void subscribeApplicationVersionAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAllowedVendorListAttribute( - AllowedVendorListAttributeCallback callback - ) { + public void readAllowedVendorListAttribute(AllowedVendorListAttributeCallback callback) { readAllowedVendorListAttribute(chipClusterPtr, callback); } + public void subscribeAllowedVendorListAttribute( - AllowedVendorListAttributeCallback callback - , - int minInterval, int maxInterval) { + AllowedVendorListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAllowedVendorListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readApplicationNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeApplicationNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeProductIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readApplicationStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeApplicationStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readApplicationVersionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeApplicationVersionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAllowedVendorListAttribute(long chipClusterPtr, - AllowedVendorListAttributeCallback callback - ); - private native void subscribeAllowedVendorListAttribute(long chipClusterPtr, - AllowedVendorListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readVendorNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeVendorNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readApplicationNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeApplicationNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeProductIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readApplicationStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeApplicationStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readApplicationVersionAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeApplicationVersionAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readAllowedVendorListAttribute( + long chipClusterPtr, AllowedVendorListAttributeCallback callback); + + private native void subscribeAllowedVendorListAttribute( + long chipClusterPtr, + AllowedVendorListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ApplicationLauncherCluster extends BaseChipCluster { @@ -660,121 +692,139 @@ public ApplicationLauncherCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void hideAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void hideAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { hideAppRequest(chipClusterPtr, callback, application, null); } - public void hideAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , int timedInvokeTimeoutMs) { + public void hideAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + int timedInvokeTimeoutMs) { hideAppRequest(chipClusterPtr, callback, application, timedInvokeTimeoutMs); } - public void launchAppRequest(LauncherResponseCallback callback - , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void launchAppRequest( + LauncherResponseCallback callback, + String data, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { launchAppRequest(chipClusterPtr, callback, data, application, null); } - public void launchAppRequest(LauncherResponseCallback callback - , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , int timedInvokeTimeoutMs) { + public void launchAppRequest( + LauncherResponseCallback callback, + String data, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + int timedInvokeTimeoutMs) { launchAppRequest(chipClusterPtr, callback, data, application, timedInvokeTimeoutMs); } - public void stopAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void stopAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { stopAppRequest(chipClusterPtr, callback, application, null); } - public void stopAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , int timedInvokeTimeoutMs) { + public void stopAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + int timedInvokeTimeoutMs) { stopAppRequest(chipClusterPtr, callback, application, timedInvokeTimeoutMs); } - private native void hideAppRequest(long chipClusterPtr, LauncherResponseCallback Callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , @Nullable Integer timedInvokeTimeoutMs); - private native void launchAppRequest(long chipClusterPtr, LauncherResponseCallback Callback - , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopAppRequest(long chipClusterPtr, LauncherResponseCallback Callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , @Nullable Integer timedInvokeTimeoutMs); + + private native void hideAppRequest( + long chipClusterPtr, + LauncherResponseCallback Callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + @Nullable Integer timedInvokeTimeoutMs); + + private native void launchAppRequest( + long chipClusterPtr, + LauncherResponseCallback Callback, + String data, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopAppRequest( + long chipClusterPtr, + LauncherResponseCallback Callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + @Nullable Integer timedInvokeTimeoutMs); + public interface LauncherResponseCallback { void onSuccess(Integer status, String data); void onError(Exception error); } + public interface ApplicationLauncherListAttributeCallback { + void onSuccess(List valueList); - public interface ApplicationLauncherListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } public void readApplicationLauncherListAttribute( - ApplicationLauncherListAttributeCallback callback - ) { + ApplicationLauncherListAttributeCallback callback) { readApplicationLauncherListAttribute(chipClusterPtr, callback); } + public void subscribeApplicationLauncherListAttribute( - ApplicationLauncherListAttributeCallback callback - , - int minInterval, int maxInterval) { + ApplicationLauncherListAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationLauncherListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readApplicationLauncherListAttribute(long chipClusterPtr, - ApplicationLauncherListAttributeCallback callback - ); - private native void subscribeApplicationLauncherListAttribute(long chipClusterPtr, - ApplicationLauncherListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readApplicationLauncherListAttribute( + long chipClusterPtr, ApplicationLauncherListAttributeCallback callback); + + private native void subscribeApplicationLauncherListAttribute( + long chipClusterPtr, + ApplicationLauncherListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class AudioOutputCluster extends BaseChipCluster { @@ -787,120 +837,118 @@ public AudioOutputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void renameOutputRequest(DefaultClusterCallback callback - , Integer index, String name) { + public void renameOutputRequest(DefaultClusterCallback callback, Integer index, String name) { renameOutputRequest(chipClusterPtr, callback, index, name, null); } - public void renameOutputRequest(DefaultClusterCallback callback - , Integer index, String name - , int timedInvokeTimeoutMs) { + public void renameOutputRequest( + DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) { renameOutputRequest(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); } - public void selectOutputRequest(DefaultClusterCallback callback - , Integer index) { + public void selectOutputRequest(DefaultClusterCallback callback, Integer index) { selectOutputRequest(chipClusterPtr, callback, index, null); } - public void selectOutputRequest(DefaultClusterCallback callback - , Integer index - , int timedInvokeTimeoutMs) { + public void selectOutputRequest( + DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) { selectOutputRequest(chipClusterPtr, callback, index, timedInvokeTimeoutMs); } - private native void renameOutputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index, String name - , @Nullable Integer timedInvokeTimeoutMs); - private native void selectOutputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index - , @Nullable Integer timedInvokeTimeoutMs); - - public interface AudioOutputListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readAudioOutputListAttribute( - AudioOutputListAttributeCallback callback - ) { + private native void renameOutputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + String name, + @Nullable Integer timedInvokeTimeoutMs); + + private native void selectOutputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AudioOutputListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readAudioOutputListAttribute(AudioOutputListAttributeCallback callback) { readAudioOutputListAttribute(chipClusterPtr, callback); } + public void subscribeAudioOutputListAttribute( - AudioOutputListAttributeCallback callback - , - int minInterval, int maxInterval) { + AudioOutputListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAudioOutputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentAudioOutputAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentAudioOutputAttribute(IntegerAttributeCallback callback) { readCurrentAudioOutputAttribute(chipClusterPtr, callback); } + public void subscribeCurrentAudioOutputAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentAudioOutputAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAudioOutputListAttribute(long chipClusterPtr, - AudioOutputListAttributeCallback callback - ); - private native void subscribeAudioOutputListAttribute(long chipClusterPtr, - AudioOutputListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentAudioOutputAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentAudioOutputAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readAudioOutputListAttribute( + long chipClusterPtr, AudioOutputListAttributeCallback callback); + + private native void subscribeAudioOutputListAttribute( + long chipClusterPtr, + AudioOutputListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentAudioOutputAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentAudioOutputAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BarrierControlCluster extends BaseChipCluster { @@ -913,153 +961,135 @@ public BarrierControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void barrierControlGoToPercent(DefaultClusterCallback callback - , Integer percentOpen) { + public void barrierControlGoToPercent(DefaultClusterCallback callback, Integer percentOpen) { barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, null); } - public void barrierControlGoToPercent(DefaultClusterCallback callback - , Integer percentOpen - , int timedInvokeTimeoutMs) { + public void barrierControlGoToPercent( + DefaultClusterCallback callback, Integer percentOpen, int timedInvokeTimeoutMs) { barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, timedInvokeTimeoutMs); } - public void barrierControlStop(DefaultClusterCallback callback - ) { + public void barrierControlStop(DefaultClusterCallback callback) { barrierControlStop(chipClusterPtr, callback, null); } - public void barrierControlStop(DefaultClusterCallback callback + public void barrierControlStop(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { barrierControlStop(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void barrierControlGoToPercent(long chipClusterPtr, DefaultClusterCallback Callback - , Integer percentOpen - , @Nullable Integer timedInvokeTimeoutMs); - private native void barrierControlStop(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void barrierControlGoToPercent( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer percentOpen, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void barrierControlStop( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readBarrierMovingStateAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readBarrierMovingStateAttribute(IntegerAttributeCallback callback) { readBarrierMovingStateAttribute(chipClusterPtr, callback); } + public void subscribeBarrierMovingStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierMovingStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierSafetyStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readBarrierSafetyStatusAttribute(IntegerAttributeCallback callback) { readBarrierSafetyStatusAttribute(chipClusterPtr, callback); } + public void subscribeBarrierSafetyStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierCapabilitiesAttribute( - IntegerAttributeCallback callback - ) { + public void readBarrierCapabilitiesAttribute(IntegerAttributeCallback callback) { readBarrierCapabilitiesAttribute(chipClusterPtr, callback); } + public void subscribeBarrierCapabilitiesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierPositionAttribute( - IntegerAttributeCallback callback - ) { + public void readBarrierPositionAttribute(IntegerAttributeCallback callback) { readBarrierPositionAttribute(chipClusterPtr, callback); } + public void subscribeBarrierPositionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBarrierMovingStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierMovingStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBarrierSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBarrierCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBarrierPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readBarrierMovingStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierMovingStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBarrierSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBarrierCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBarrierPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BasicCluster extends BaseChipCluster { @@ -1072,442 +1102,420 @@ public BasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface VendorIDAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface VendorIDAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readInteractionModelVersionAttribute( - IntegerAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readInteractionModelVersionAttribute(IntegerAttributeCallback callback) { readInteractionModelVersionAttribute(chipClusterPtr, callback); } + public void subscribeInteractionModelVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInteractionModelVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorNameAttribute( - CharStringAttributeCallback callback - ) { + public void readVendorNameAttribute(CharStringAttributeCallback callback) { readVendorNameAttribute(chipClusterPtr, callback); } + public void subscribeVendorNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIDAttribute( - VendorIDAttributeCallback callback - ) { + public void readVendorIDAttribute(VendorIDAttributeCallback callback) { readVendorIDAttribute(chipClusterPtr, callback); } + public void subscribeVendorIDAttribute( - VendorIDAttributeCallback callback - , - int minInterval, int maxInterval) { + VendorIDAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductNameAttribute( - CharStringAttributeCallback callback - ) { + public void readProductNameAttribute(CharStringAttributeCallback callback) { readProductNameAttribute(chipClusterPtr, callback); } + public void subscribeProductNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductIDAttribute( - IntegerAttributeCallback callback - ) { + public void readProductIDAttribute(IntegerAttributeCallback callback) { readProductIDAttribute(chipClusterPtr, callback); } + public void subscribeProductIDAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNodeLabelAttribute( - CharStringAttributeCallback callback - ) { + public void readNodeLabelAttribute(CharStringAttributeCallback callback) { readNodeLabelAttribute(chipClusterPtr, callback); } + public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value) { writeNodeLabelAttribute(chipClusterPtr, callback, value, null); } - public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeNodeLabelAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeNodeLabelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNodeLabelAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNodeLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocationAttribute( - CharStringAttributeCallback callback - ) { + public void readLocationAttribute(CharStringAttributeCallback callback) { readLocationAttribute(chipClusterPtr, callback); } + public void writeLocationAttribute(DefaultClusterCallback callback, String value) { writeLocationAttribute(chipClusterPtr, callback, value, null); } - public void writeLocationAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLocationAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLocationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLocationAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readHardwareVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readHardwareVersionAttribute(IntegerAttributeCallback callback) { readHardwareVersionAttribute(chipClusterPtr, callback); } + public void subscribeHardwareVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeHardwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readHardwareVersionStringAttribute( - CharStringAttributeCallback callback - ) { + public void readHardwareVersionStringAttribute(CharStringAttributeCallback callback) { readHardwareVersionStringAttribute(chipClusterPtr, callback); } + public void subscribeHardwareVersionStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeHardwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoftwareVersionAttribute( - LongAttributeCallback callback - ) { + public void readSoftwareVersionAttribute(LongAttributeCallback callback) { readSoftwareVersionAttribute(chipClusterPtr, callback); } + public void subscribeSoftwareVersionAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeSoftwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoftwareVersionStringAttribute( - CharStringAttributeCallback callback - ) { + public void readSoftwareVersionStringAttribute(CharStringAttributeCallback callback) { readSoftwareVersionStringAttribute(chipClusterPtr, callback); } + public void subscribeSoftwareVersionStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeSoftwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readManufacturingDateAttribute( - CharStringAttributeCallback callback - ) { + public void readManufacturingDateAttribute(CharStringAttributeCallback callback) { readManufacturingDateAttribute(chipClusterPtr, callback); } + public void subscribeManufacturingDateAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeManufacturingDateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartNumberAttribute( - CharStringAttributeCallback callback - ) { + public void readPartNumberAttribute(CharStringAttributeCallback callback) { readPartNumberAttribute(chipClusterPtr, callback); } + public void subscribePartNumberAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribePartNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductURLAttribute( - CharStringAttributeCallback callback - ) { + public void readProductURLAttribute(CharStringAttributeCallback callback) { readProductURLAttribute(chipClusterPtr, callback); } + public void subscribeProductURLAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductURLAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductLabelAttribute( - CharStringAttributeCallback callback - ) { + public void readProductLabelAttribute(CharStringAttributeCallback callback) { readProductLabelAttribute(chipClusterPtr, callback); } + public void subscribeProductLabelAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSerialNumberAttribute( - CharStringAttributeCallback callback - ) { + public void readSerialNumberAttribute(CharStringAttributeCallback callback) { readSerialNumberAttribute(chipClusterPtr, callback); } + public void subscribeSerialNumberAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeSerialNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocalConfigDisabledAttribute( - BooleanAttributeCallback callback - ) { + public void readLocalConfigDisabledAttribute(BooleanAttributeCallback callback) { readLocalConfigDisabledAttribute(chipClusterPtr, callback); } + public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value) { writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, null); } - public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeLocalConfigDisabledAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLocalConfigDisabledAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocalConfigDisabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readReachableAttribute( - BooleanAttributeCallback callback - ) { + public void readReachableAttribute(BooleanAttributeCallback callback) { readReachableAttribute(chipClusterPtr, callback); } + public void subscribeReachableAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeReachableAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUniqueIDAttribute( - CharStringAttributeCallback callback - ) { + public void readUniqueIDAttribute(CharStringAttributeCallback callback) { readUniqueIDAttribute(chipClusterPtr, callback); } + public void subscribeUniqueIDAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeUniqueIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readInteractionModelVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInteractionModelVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorIDAttribute(long chipClusterPtr, - VendorIDAttributeCallback callback - ); - private native void subscribeVendorIDAttribute(long chipClusterPtr, - VendorIDAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readProductNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeProductNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductIDAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeProductIDAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNodeLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeNodeLabelAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNodeLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLocationAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeLocationAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLocationAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readHardwareVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeHardwareVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readHardwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeHardwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSoftwareVersionAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeSoftwareVersionAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSoftwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeSoftwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readManufacturingDateAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeManufacturingDateAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPartNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribePartNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductURLAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeProductURLAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeProductLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSerialNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeSerialNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLocalConfigDisabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeLocalConfigDisabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLocalConfigDisabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readReachableAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeReachableAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUniqueIDAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeUniqueIDAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readInteractionModelVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInteractionModelVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readVendorNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeVendorNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readVendorIDAttribute( + long chipClusterPtr, VendorIDAttributeCallback callback); + + private native void subscribeVendorIDAttribute( + long chipClusterPtr, VendorIDAttributeCallback callback, int minInterval, int maxInterval); + + private native void readProductNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeProductNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductIDAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeProductIDAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNodeLabelAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeNodeLabelAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNodeLabelAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLocationAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeLocationAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLocationAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readHardwareVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeHardwareVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readHardwareVersionStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeHardwareVersionStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSoftwareVersionAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeSoftwareVersionAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSoftwareVersionStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeSoftwareVersionStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readManufacturingDateAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeManufacturingDateAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPartNumberAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribePartNumberAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductURLAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeProductURLAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductLabelAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeProductLabelAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSerialNumberAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeSerialNumberAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLocalConfigDisabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeLocalConfigDisabledAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLocalConfigDisabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readReachableAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeReachableAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUniqueIDAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeUniqueIDAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BinaryInputBasicCluster extends BaseChipCluster { @@ -1520,207 +1528,230 @@ public BinaryInputBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readOutOfServiceAttribute( - BooleanAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readOutOfServiceAttribute(BooleanAttributeCallback callback) { readOutOfServiceAttribute(chipClusterPtr, callback); } + public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value) { writeOutOfServiceAttribute(chipClusterPtr, callback, value, null); } - public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeOutOfServiceAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeOutOfServiceAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOutOfServiceAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeOutOfServiceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPresentValueAttribute( - BooleanAttributeCallback callback - ) { + public void readPresentValueAttribute(BooleanAttributeCallback callback) { readPresentValueAttribute(chipClusterPtr, callback); } + public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value) { writePresentValueAttribute(chipClusterPtr, callback, value, null); } - public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writePresentValueAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writePresentValueAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribePresentValueAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribePresentValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStatusFlagsAttribute( - IntegerAttributeCallback callback - ) { + public void readStatusFlagsAttribute(IntegerAttributeCallback callback) { readStatusFlagsAttribute(chipClusterPtr, callback); } + public void subscribeStatusFlagsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStatusFlagsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOutOfServiceAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeOutOfServiceAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOutOfServiceAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPresentValueAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writePresentValueAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribePresentValueAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStatusFlagsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStatusFlagsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + private native void readOutOfServiceAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); - public static class BindingCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 30L; + private native void writeOutOfServiceAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); - public BindingCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void subscribeOutOfServiceAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPresentValueAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writePresentValueAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribePresentValueAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStatusFlagsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStatusFlagsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class BindingCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 30L; + + public BindingCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } @Override public native long initWithDevice(long devicePtr, int endpointId); - public void bind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId) { + public void bind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId) { bind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, null); } - public void bind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , int timedInvokeTimeoutMs) { + public void bind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + int timedInvokeTimeoutMs) { bind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); } - public void unbind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId) { + public void unbind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId) { unbind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, null); } - public void unbind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , int timedInvokeTimeoutMs) { - unbind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); + public void unbind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + int timedInvokeTimeoutMs) { + unbind( + chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); } - private native void bind(long chipClusterPtr, DefaultClusterCallback Callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , @Nullable Integer timedInvokeTimeoutMs); - private native void unbind(long chipClusterPtr, DefaultClusterCallback Callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void bind( + long chipClusterPtr, + DefaultClusterCallback Callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void unbind( + long chipClusterPtr, + DefaultClusterCallback Callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 BooleanStateCluster extends BaseChipCluster { @@ -1733,68 +1764,61 @@ public BooleanStateCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readStateValueAttribute( - BooleanAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readStateValueAttribute(BooleanAttributeCallback callback) { readStateValueAttribute(chipClusterPtr, callback); } + public void subscribeStateValueAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeStateValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readStateValueAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeStateValueAttribute(long chipClusterPtr, - BooleanAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readStateValueAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeStateValueAttribute( + long chipClusterPtr, BooleanAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BridgedActionsCluster extends BaseChipCluster { @@ -1807,284 +1831,375 @@ public BridgedActionsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void disableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void disableAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { disableAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void disableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void disableAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { disableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void disableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void disableActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void disableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void disableActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + disableActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void enableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void enableAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { enableAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void enableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void enableAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { enableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void enableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void enableActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void enableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void enableActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + enableActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void instantAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void instantAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { instantAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void instantAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void instantAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { instantAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void instantActionWithTransition(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Integer transitionTime) { - instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, null); + public void instantActionWithTransition( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Integer transitionTime) { + instantActionWithTransition( + chipClusterPtr, callback, actionID, invokeID, transitionTime, null); } - public void instantActionWithTransition(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Integer transitionTime - , int timedInvokeTimeoutMs) { - instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs); + public void instantActionWithTransition( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Integer transitionTime, + int timedInvokeTimeoutMs) { + instantActionWithTransition( + chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs); } - public void pauseAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void pauseAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { pauseAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void pauseAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void pauseAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { pauseAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void pauseActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void pauseActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void pauseActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void pauseActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + pauseActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void resumeAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void resumeAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { resumeAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void resumeAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void resumeAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { resumeAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void startAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void startAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { startAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void startAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void startAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { startAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void startActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void startActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void startActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void startActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + startActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void stopAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void stopAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { stopAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void stopAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void stopAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { stopAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - private native void disableAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void disableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void enableAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void enableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void instantAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void instantActionWithTransition(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void pauseAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void pauseActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void resumeAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void startAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void startActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - - public interface ActionListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface EndpointListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readActionListAttribute( - ActionListAttributeCallback callback - ) { + private native void disableAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void disableActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enableAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enableActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void instantAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void instantActionWithTransition( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void pauseAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void pauseActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void resumeAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void startAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void startActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + public interface ActionListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface EndpointListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readActionListAttribute(ActionListAttributeCallback callback) { readActionListAttribute(chipClusterPtr, callback); } + public void subscribeActionListAttribute( - ActionListAttributeCallback callback - , - int minInterval, int maxInterval) { + ActionListAttributeCallback callback, int minInterval, int maxInterval) { subscribeActionListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEndpointListAttribute( - EndpointListAttributeCallback callback - ) { + public void readEndpointListAttribute(EndpointListAttributeCallback callback) { readEndpointListAttribute(chipClusterPtr, callback); } + public void subscribeEndpointListAttribute( - EndpointListAttributeCallback callback - , - int minInterval, int maxInterval) { + EndpointListAttributeCallback callback, int minInterval, int maxInterval) { subscribeEndpointListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSetupUrlAttribute( - CharStringAttributeCallback callback - ) { + public void readSetupUrlAttribute(CharStringAttributeCallback callback) { readSetupUrlAttribute(chipClusterPtr, callback); } + public void subscribeSetupUrlAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeSetupUrlAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readActionListAttribute(long chipClusterPtr, - ActionListAttributeCallback callback - ); - private native void subscribeActionListAttribute(long chipClusterPtr, - ActionListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readEndpointListAttribute(long chipClusterPtr, - EndpointListAttributeCallback callback - ); - private native void subscribeEndpointListAttribute(long chipClusterPtr, - EndpointListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readSetupUrlAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeSetupUrlAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readActionListAttribute( + long chipClusterPtr, ActionListAttributeCallback callback); + + private native void subscribeActionListAttribute( + long chipClusterPtr, + ActionListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEndpointListAttribute( + long chipClusterPtr, EndpointListAttributeCallback callback); + + private native void subscribeEndpointListAttribute( + long chipClusterPtr, + EndpointListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSetupUrlAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeSetupUrlAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BridgedDeviceBasicCluster extends BaseChipCluster { @@ -2097,49 +2212,46 @@ public BridgedDeviceBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - private native void readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ChannelCluster extends BaseChipCluster { @@ -2152,121 +2264,129 @@ public ChannelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void changeChannelByNumberRequest(DefaultClusterCallback callback - , Integer majorNumber, Integer minorNumber) { + public void changeChannelByNumberRequest( + DefaultClusterCallback callback, Integer majorNumber, Integer minorNumber) { changeChannelByNumberRequest(chipClusterPtr, callback, majorNumber, minorNumber, null); } - public void changeChannelByNumberRequest(DefaultClusterCallback callback - , Integer majorNumber, Integer minorNumber - , int timedInvokeTimeoutMs) { - changeChannelByNumberRequest(chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs); + public void changeChannelByNumberRequest( + DefaultClusterCallback callback, + Integer majorNumber, + Integer minorNumber, + int timedInvokeTimeoutMs) { + changeChannelByNumberRequest( + chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs); } - public void changeChannelRequest(ChangeChannelResponseCallback callback - , String match) { + public void changeChannelRequest(ChangeChannelResponseCallback callback, String match) { changeChannelRequest(chipClusterPtr, callback, match, null); } - public void changeChannelRequest(ChangeChannelResponseCallback callback - , String match - , int timedInvokeTimeoutMs) { + public void changeChannelRequest( + ChangeChannelResponseCallback callback, String match, int timedInvokeTimeoutMs) { changeChannelRequest(chipClusterPtr, callback, match, timedInvokeTimeoutMs); } - public void skipChannelRequest(DefaultClusterCallback callback - , Integer count) { + public void skipChannelRequest(DefaultClusterCallback callback, Integer count) { skipChannelRequest(chipClusterPtr, callback, count, null); } - public void skipChannelRequest(DefaultClusterCallback callback - , Integer count - , int timedInvokeTimeoutMs) { + public void skipChannelRequest( + DefaultClusterCallback callback, Integer count, int timedInvokeTimeoutMs) { skipChannelRequest(chipClusterPtr, callback, count, timedInvokeTimeoutMs); } - private native void changeChannelByNumberRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer majorNumber, Integer minorNumber - , @Nullable Integer timedInvokeTimeoutMs); - private native void changeChannelRequest(long chipClusterPtr, ChangeChannelResponseCallback Callback - , String match - , @Nullable Integer timedInvokeTimeoutMs); - private native void skipChannelRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer count - , @Nullable Integer timedInvokeTimeoutMs); + + private native void changeChannelByNumberRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer majorNumber, + Integer minorNumber, + @Nullable Integer timedInvokeTimeoutMs); + + private native void changeChannelRequest( + long chipClusterPtr, + ChangeChannelResponseCallback Callback, + String match, + @Nullable Integer timedInvokeTimeoutMs); + + private native void skipChannelRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer count, + @Nullable Integer timedInvokeTimeoutMs); + public interface ChangeChannelResponseCallback { void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType); void onError(Exception error); } + public interface ChannelListAttributeCallback { + void onSuccess(List valueList); - public interface ChannelListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readChannelListAttribute( - ChannelListAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readChannelListAttribute(ChannelListAttributeCallback callback) { readChannelListAttribute(chipClusterPtr, callback); } + public void subscribeChannelListAttribute( - ChannelListAttributeCallback callback - , - int minInterval, int maxInterval) { + ChannelListAttributeCallback callback, int minInterval, int maxInterval) { subscribeChannelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readChannelListAttribute(long chipClusterPtr, - ChannelListAttributeCallback callback - ); - private native void subscribeChannelListAttribute(long chipClusterPtr, - ChannelListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readChannelListAttribute( + long chipClusterPtr, ChannelListAttributeCallback callback); + + private native void subscribeChannelListAttribute( + long chipClusterPtr, + ChannelListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ColorControlCluster extends BaseChipCluster { @@ -2279,1561 +2399,2031 @@ public ColorControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void colorLoopSet(DefaultClusterCallback callback - , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride) { - colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, null); - } - - public void colorLoopSet(DefaultClusterCallback callback - , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedMoveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + public void colorLoopSet( + DefaultClusterCallback callback, + Integer updateFlags, + Integer action, + Integer direction, + Integer time, + Integer startHue, + Integer optionsMask, + Integer optionsOverride) { + colorLoopSet( + chipClusterPtr, + callback, + updateFlags, + action, + direction, + time, + startHue, + optionsMask, + optionsOverride, + null); + } + + public void colorLoopSet( + DefaultClusterCallback callback, + Integer updateFlags, + Integer action, + Integer direction, + Integer time, + Integer startHue, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + colorLoopSet( + chipClusterPtr, + callback, + updateFlags, + action, + direction, + time, + startHue, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedMoveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride) { enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void enhancedMoveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedMoveToHue(DefaultClusterCallback callback - , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, null); - } - - public void enhancedMoveToHue(DefaultClusterCallback callback - , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback - , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, null); - } - - public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback - , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedStepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); - } - - public void enhancedStepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveColor(DefaultClusterCallback callback - , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride) { + public void enhancedMoveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedMoveHue( + chipClusterPtr, + callback, + moveMode, + rate, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedMoveToHue( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + enhancedMoveToHue( + chipClusterPtr, + callback, + enhancedHue, + direction, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void enhancedMoveToHue( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedMoveToHue( + chipClusterPtr, + callback, + enhancedHue, + direction, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedMoveToHueAndSaturation( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + enhancedMoveToHueAndSaturation( + chipClusterPtr, + callback, + enhancedHue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void enhancedMoveToHueAndSaturation( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedMoveToHueAndSaturation( + chipClusterPtr, + callback, + enhancedHue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedStepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + enhancedStepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void enhancedStepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedStepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveColor( + DefaultClusterCallback callback, + Integer rateX, + Integer rateY, + Integer optionsMask, + Integer optionsOverride) { moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, null); } - public void moveColor(DefaultClusterCallback callback - , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveColorTemperature(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride) { - moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, null); - } - - public void moveColorTemperature(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + public void moveColor( + DefaultClusterCallback callback, + Integer rateX, + Integer rateY, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveColor( + chipClusterPtr, + callback, + rateX, + rateY, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveColorTemperature( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride) { + moveColorTemperature( + chipClusterPtr, + callback, + moveMode, + rate, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + null); + } + + public void moveColorTemperature( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveColorTemperature( + chipClusterPtr, + callback, + moveMode, + rate, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride) { moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void moveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveSaturation(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + public void moveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveHue( + chipClusterPtr, + callback, + moveMode, + rate, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveSaturation( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride) { moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void moveSaturation(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToColor(DefaultClusterCallback callback - , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToColor(DefaultClusterCallback callback - , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToColorTemperature(DefaultClusterCallback callback - , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToColorTemperature(chipClusterPtr, callback, colorTemperature, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToColorTemperature(DefaultClusterCallback callback - , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToColorTemperature(chipClusterPtr, callback, colorTemperature, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToHue(DefaultClusterCallback callback - , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToHue(DefaultClusterCallback callback - , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToHueAndSaturation(DefaultClusterCallback callback - , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToHueAndSaturation(DefaultClusterCallback callback - , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToSaturation(DefaultClusterCallback callback - , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToSaturation(DefaultClusterCallback callback - , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepColor(DefaultClusterCallback callback - , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, null); - } - - public void stepColor(DefaultClusterCallback callback - , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepColorTemperature(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride) { - stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, null); - } - - public void stepColorTemperature(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); - } - - public void stepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepSaturation(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); - } - - public void stepSaturation(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stopMoveStep(DefaultClusterCallback callback - , Integer optionsMask, Integer optionsOverride) { + public void moveSaturation( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveSaturation( + chipClusterPtr, + callback, + moveMode, + rate, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToColor( + DefaultClusterCallback callback, + Integer colorX, + Integer colorY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToColor( + chipClusterPtr, + callback, + colorX, + colorY, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToColor( + DefaultClusterCallback callback, + Integer colorX, + Integer colorY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToColor( + chipClusterPtr, + callback, + colorX, + colorY, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToColorTemperature( + DefaultClusterCallback callback, + Integer colorTemperature, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToColorTemperature( + chipClusterPtr, + callback, + colorTemperature, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToColorTemperature( + DefaultClusterCallback callback, + Integer colorTemperature, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToColorTemperature( + chipClusterPtr, + callback, + colorTemperature, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToHue( + DefaultClusterCallback callback, + Integer hue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToHue( + chipClusterPtr, + callback, + hue, + direction, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToHue( + DefaultClusterCallback callback, + Integer hue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToHue( + chipClusterPtr, + callback, + hue, + direction, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToHueAndSaturation( + DefaultClusterCallback callback, + Integer hue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToHueAndSaturation( + chipClusterPtr, + callback, + hue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToHueAndSaturation( + DefaultClusterCallback callback, + Integer hue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToHueAndSaturation( + chipClusterPtr, + callback, + hue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToSaturation( + DefaultClusterCallback callback, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToSaturation( + chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToSaturation( + DefaultClusterCallback callback, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToSaturation( + chipClusterPtr, + callback, + saturation, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepColor( + DefaultClusterCallback callback, + Integer stepX, + Integer stepY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + stepColor( + chipClusterPtr, + callback, + stepX, + stepY, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void stepColor( + DefaultClusterCallback callback, + Integer stepX, + Integer stepY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepColor( + chipClusterPtr, + callback, + stepX, + stepY, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepColorTemperature( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride) { + stepColorTemperature( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + null); + } + + public void stepColorTemperature( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepColorTemperature( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + stepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void stepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepSaturation( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + stepSaturation( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void stepSaturation( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepSaturation( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stopMoveStep( + DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride) { stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, null); } - public void stopMoveStep(DefaultClusterCallback callback - , Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { + public void stopMoveStep( + DefaultClusterCallback callback, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, timedInvokeTimeoutMs); } - private native void colorLoopSet(long chipClusterPtr, DefaultClusterCallback Callback - , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedMoveHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedMoveToHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedMoveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedStepHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveColor(long chipClusterPtr, DefaultClusterCallback Callback - , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToColor(long chipClusterPtr, DefaultClusterCallback Callback - , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback - , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepColor(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopMoveStep(long chipClusterPtr, DefaultClusterCallback Callback - , Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readCurrentHueAttribute( - IntegerAttributeCallback callback - ) { + private native void colorLoopSet( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer updateFlags, + Integer action, + Integer direction, + Integer time, + Integer startHue, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedMoveHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedMoveToHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer enhancedHue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedMoveToHueAndSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer enhancedHue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedStepHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveColor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer rateX, + Integer rateY, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveColorTemperature( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToColor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer colorX, + Integer colorY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToColorTemperature( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer colorTemperature, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer hue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToHueAndSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer hue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepColor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepX, + Integer stepY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepColorTemperature( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopMoveStep( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readCurrentHueAttribute(IntegerAttributeCallback callback) { readCurrentHueAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentSaturationAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentSaturationAttribute(IntegerAttributeCallback callback) { readCurrentSaturationAttribute(chipClusterPtr, callback); } + public void subscribeCurrentSaturationAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentSaturationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRemainingTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readRemainingTimeAttribute(IntegerAttributeCallback callback) { readRemainingTimeAttribute(chipClusterPtr, callback); } + public void subscribeRemainingTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentXAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentXAttribute(IntegerAttributeCallback callback) { readCurrentXAttribute(chipClusterPtr, callback); } + public void subscribeCurrentXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentYAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentYAttribute(IntegerAttributeCallback callback) { readCurrentYAttribute(chipClusterPtr, callback); } + public void subscribeCurrentYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDriftCompensationAttribute( - IntegerAttributeCallback callback - ) { + public void readDriftCompensationAttribute(IntegerAttributeCallback callback) { readDriftCompensationAttribute(chipClusterPtr, callback); } + public void subscribeDriftCompensationAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeDriftCompensationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCompensationTextAttribute( - CharStringAttributeCallback callback - ) { + public void readCompensationTextAttribute(CharStringAttributeCallback callback) { readCompensationTextAttribute(chipClusterPtr, callback); } + public void subscribeCompensationTextAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeCompensationTextAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTemperatureAttribute( - IntegerAttributeCallback callback - ) { + public void readColorTemperatureAttribute(IntegerAttributeCallback callback) { readColorTemperatureAttribute(chipClusterPtr, callback); } + public void subscribeColorTemperatureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorModeAttribute( - IntegerAttributeCallback callback - ) { + public void readColorModeAttribute(IntegerAttributeCallback callback) { readColorModeAttribute(chipClusterPtr, callback); } + public void subscribeColorModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorControlOptionsAttribute( - IntegerAttributeCallback callback - ) { + public void readColorControlOptionsAttribute(IntegerAttributeCallback callback) { readColorControlOptionsAttribute(chipClusterPtr, callback); } + public void writeColorControlOptionsAttribute(DefaultClusterCallback callback, Integer value) { writeColorControlOptionsAttribute(chipClusterPtr, callback, value, null); } - public void writeColorControlOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorControlOptionsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorControlOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorControlOptionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorControlOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfPrimariesAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfPrimariesAttribute(IntegerAttributeCallback callback) { readNumberOfPrimariesAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfPrimariesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNumberOfPrimariesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary1XAttribute(IntegerAttributeCallback callback) { readPrimary1XAttribute(chipClusterPtr, callback); } + public void subscribePrimary1XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary1XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary1YAttribute(IntegerAttributeCallback callback) { readPrimary1YAttribute(chipClusterPtr, callback); } + public void subscribePrimary1YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary1YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary1IntensityAttribute(IntegerAttributeCallback callback) { readPrimary1IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary1IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary1IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary2XAttribute(IntegerAttributeCallback callback) { readPrimary2XAttribute(chipClusterPtr, callback); } + public void subscribePrimary2XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary2XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary2YAttribute(IntegerAttributeCallback callback) { readPrimary2YAttribute(chipClusterPtr, callback); } + public void subscribePrimary2YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary2YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary2IntensityAttribute(IntegerAttributeCallback callback) { readPrimary2IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary2IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary2IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary3XAttribute(IntegerAttributeCallback callback) { readPrimary3XAttribute(chipClusterPtr, callback); } + public void subscribePrimary3XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary3XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary3YAttribute(IntegerAttributeCallback callback) { readPrimary3YAttribute(chipClusterPtr, callback); } + public void subscribePrimary3YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary3YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary3IntensityAttribute(IntegerAttributeCallback callback) { readPrimary3IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary3IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary3IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary4XAttribute(IntegerAttributeCallback callback) { readPrimary4XAttribute(chipClusterPtr, callback); } + public void subscribePrimary4XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary4XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary4YAttribute(IntegerAttributeCallback callback) { readPrimary4YAttribute(chipClusterPtr, callback); } + public void subscribePrimary4YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary4YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary4IntensityAttribute(IntegerAttributeCallback callback) { readPrimary4IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary4IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary4IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary5XAttribute(IntegerAttributeCallback callback) { readPrimary5XAttribute(chipClusterPtr, callback); } + public void subscribePrimary5XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary5XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary5YAttribute(IntegerAttributeCallback callback) { readPrimary5YAttribute(chipClusterPtr, callback); } + public void subscribePrimary5YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary5YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary5IntensityAttribute(IntegerAttributeCallback callback) { readPrimary5IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary5IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary5IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary6XAttribute(IntegerAttributeCallback callback) { readPrimary6XAttribute(chipClusterPtr, callback); } + public void subscribePrimary6XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary6XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary6YAttribute(IntegerAttributeCallback callback) { readPrimary6YAttribute(chipClusterPtr, callback); } + public void subscribePrimary6YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary6YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary6IntensityAttribute(IntegerAttributeCallback callback) { readPrimary6IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary6IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary6IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWhitePointXAttribute( - IntegerAttributeCallback callback - ) { + public void readWhitePointXAttribute(IntegerAttributeCallback callback) { readWhitePointXAttribute(chipClusterPtr, callback); } + public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value) { writeWhitePointXAttribute(chipClusterPtr, callback, value, null); } - public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWhitePointXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWhitePointXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeWhitePointXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWhitePointXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWhitePointYAttribute( - IntegerAttributeCallback callback - ) { + public void readWhitePointYAttribute(IntegerAttributeCallback callback) { readWhitePointYAttribute(chipClusterPtr, callback); } + public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value) { writeWhitePointYAttribute(chipClusterPtr, callback, value, null); } - public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWhitePointYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWhitePointYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeWhitePointYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWhitePointYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRXAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointRXAttribute(IntegerAttributeCallback callback) { readColorPointRXAttribute(chipClusterPtr, callback); } + public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointRXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointRXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRYAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointRYAttribute(IntegerAttributeCallback callback) { readColorPointRYAttribute(chipClusterPtr, callback); } + public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointRYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointRYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRIntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointRIntensityAttribute(IntegerAttributeCallback callback) { readColorPointRIntensityAttribute(chipClusterPtr, callback); } + public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRIntensityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointRIntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointRIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGXAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointGXAttribute(IntegerAttributeCallback callback) { readColorPointGXAttribute(chipClusterPtr, callback); } + public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointGXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointGXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGYAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointGYAttribute(IntegerAttributeCallback callback) { readColorPointGYAttribute(chipClusterPtr, callback); } + public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointGYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointGYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGIntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointGIntensityAttribute(IntegerAttributeCallback callback) { readColorPointGIntensityAttribute(chipClusterPtr, callback); } + public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGIntensityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointGIntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointGIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBXAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointBXAttribute(IntegerAttributeCallback callback) { readColorPointBXAttribute(chipClusterPtr, callback); } + public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointBXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointBXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBYAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointBYAttribute(IntegerAttributeCallback callback) { readColorPointBYAttribute(chipClusterPtr, callback); } + public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointBYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointBYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBIntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointBIntensityAttribute(IntegerAttributeCallback callback) { readColorPointBIntensityAttribute(chipClusterPtr, callback); } + public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBIntensityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointBIntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointBIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnhancedCurrentHueAttribute( - IntegerAttributeCallback callback - ) { + public void readEnhancedCurrentHueAttribute(IntegerAttributeCallback callback) { readEnhancedCurrentHueAttribute(chipClusterPtr, callback); } + public void subscribeEnhancedCurrentHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnhancedCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnhancedColorModeAttribute( - IntegerAttributeCallback callback - ) { + public void readEnhancedColorModeAttribute(IntegerAttributeCallback callback) { readEnhancedColorModeAttribute(chipClusterPtr, callback); } + public void subscribeEnhancedColorModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnhancedColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopActiveAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopActiveAttribute(IntegerAttributeCallback callback) { readColorLoopActiveAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopActiveAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorLoopActiveAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopDirectionAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopDirectionAttribute(IntegerAttributeCallback callback) { readColorLoopDirectionAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopDirectionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorLoopDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopTimeAttribute(IntegerAttributeCallback callback) { readColorLoopTimeAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorLoopTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopStartEnhancedHueAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopStartEnhancedHueAttribute(IntegerAttributeCallback callback) { readColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopStartEnhancedHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeColorLoopStartEnhancedHueAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopStoredEnhancedHueAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopStoredEnhancedHueAttribute(IntegerAttributeCallback callback) { readColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopStoredEnhancedHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeColorLoopStoredEnhancedHueAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorCapabilitiesAttribute( - IntegerAttributeCallback callback - ) { + public void readColorCapabilitiesAttribute(IntegerAttributeCallback callback) { readColorCapabilitiesAttribute(chipClusterPtr, callback); } + public void subscribeColorCapabilitiesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTempPhysicalMinAttribute( - IntegerAttributeCallback callback - ) { + public void readColorTempPhysicalMinAttribute(IntegerAttributeCallback callback) { readColorTempPhysicalMinAttribute(chipClusterPtr, callback); } + public void subscribeColorTempPhysicalMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorTempPhysicalMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTempPhysicalMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readColorTempPhysicalMaxAttribute(IntegerAttributeCallback callback) { readColorTempPhysicalMaxAttribute(chipClusterPtr, callback); } + public void subscribeColorTempPhysicalMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorTempPhysicalMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCoupleColorTempToLevelMinMiredsAttribute( - IntegerAttributeCallback callback - ) { + public void readCoupleColorTempToLevelMinMiredsAttribute(IntegerAttributeCallback callback) { readCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback); } + public void subscribeCoupleColorTempToLevelMinMiredsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCoupleColorTempToLevelMinMiredsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpColorTemperatureMiredsAttribute( - IntegerAttributeCallback callback - ) { + public void readStartUpColorTemperatureMiredsAttribute(IntegerAttributeCallback callback) { readStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback); } - public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeStartUpColorTemperatureMiredsAttribute( + DefaultClusterCallback callback, Integer value) { writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeStartUpColorTemperatureMiredsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpColorTemperatureMiredsAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeStartUpColorTemperatureMiredsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeStartUpColorTemperatureMiredsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentSaturationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentSaturationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDriftCompensationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeDriftCompensationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCompensationTextAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeCompensationTextAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorControlOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorControlOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorControlOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfPrimariesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfPrimariesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary1XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary1XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary1YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary1YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary1IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary1IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary2XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary2XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary2YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary2YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary2IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary2IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary3XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary3XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary3YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary3YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary3IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary3IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary4XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary4XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary4YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary4YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary4IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary4IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary5XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary5XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary5YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary5YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary5IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary5IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary6XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary6XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary6YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary6YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary6IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary6IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWhitePointXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeWhitePointXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeWhitePointXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWhitePointYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeWhitePointYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeWhitePointYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointRXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointRXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointRXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointRYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointRYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointRYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointRIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointRIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointRIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointGXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointGXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointGXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointGYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointGYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointGYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointGIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointGIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointGIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointBXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointBXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointBXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointBYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointBYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointBYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointBIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointBIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointBIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnhancedCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEnhancedCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnhancedColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEnhancedColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopActiveAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopActiveAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopDirectionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopDirectionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopStartEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopStartEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorTempPhysicalMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorTempPhysicalMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorTempPhysicalMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorTempPhysicalMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + private native void readCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public static class ContentLauncherCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1290L; + private native void subscribeCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public ContentLauncherCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void readCurrentSaturationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - @Override - public native long initWithDevice(long devicePtr, int endpointId); + private native void subscribeCurrentSaturationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void launchContentRequest(LaunchResponseCallback callback - , Boolean autoPlay, String data, ArrayList search) { - launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, null); - } + private native void readRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void launchContentRequest(LaunchResponseCallback callback - , Boolean autoPlay, String data, ArrayList search - , int timedInvokeTimeoutMs) { - launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, timedInvokeTimeoutMs); - } + private native void subscribeRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void launchURLRequest(LaunchResponseCallback callback - , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation) { - launchURLRequest(chipClusterPtr, callback, contentURL, displayString, brandingInformation, null); - } + private native void readCurrentXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void launchURLRequest(LaunchResponseCallback callback - , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation - , int timedInvokeTimeoutMs) { - launchURLRequest(chipClusterPtr, callback, contentURL, displayString, brandingInformation, timedInvokeTimeoutMs); - } - private native void launchContentRequest(long chipClusterPtr, LaunchResponseCallback Callback - , Boolean autoPlay, String data, ArrayList search - , @Nullable Integer timedInvokeTimeoutMs); - private native void launchURLRequest(long chipClusterPtr, LaunchResponseCallback Callback - , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation - , @Nullable Integer timedInvokeTimeoutMs); - public interface LaunchResponseCallback { - void onSuccess(Integer status, String data); + private native void subscribeCurrentXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - void onError(Exception error); - } + private native void readCurrentYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + private native void subscribeCurrentYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public interface AcceptHeaderListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void readDriftCompensationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readAcceptHeaderListAttribute( - AcceptHeaderListAttributeCallback callback - ) { - readAcceptHeaderListAttribute(chipClusterPtr, callback); - } - public void subscribeAcceptHeaderListAttribute( - AcceptHeaderListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAcceptHeaderListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeDriftCompensationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readSupportedStreamingProtocolsAttribute( - LongAttributeCallback callback - ) { - readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback); - } - public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value) { - writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, null); - } + private native void readCompensationTextAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); - public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { - writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); - } - public void subscribeSupportedStreamingProtocolsAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeCompensationTextAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { - readAttributeListAttribute(chipClusterPtr, callback); - } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readColorTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { - readClusterRevisionAttribute(chipClusterPtr, callback); - } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + private native void subscribeColorTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorControlOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorControlOptionsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorControlOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfPrimariesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfPrimariesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary1XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary1XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary1YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary1YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary1IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary1IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary2XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary2XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary2YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary2YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary2IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary2IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary3XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary3XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary3YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary3YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary3IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary3IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary4XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary4XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary4YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary4YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary4IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary4IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary5XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary5XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary5YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary5YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary5IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary5IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary6XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary6XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary6YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary6YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary6IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary6IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWhitePointXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeWhitePointXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeWhitePointXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWhitePointYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeWhitePointYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeWhitePointYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointRXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointRXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointRXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointRYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointRYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointRYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointRIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointRIntensityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointRIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointGXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointGXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointGXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointGYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointGYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointGYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointGIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointGIntensityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointGIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointBXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointBXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointBXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointBYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointBYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointBYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointBIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointBIntensityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointBIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnhancedCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEnhancedCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnhancedColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEnhancedColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopActiveAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopActiveAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopDirectionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopDirectionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopStartEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopStartEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopStoredEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopStoredEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorTempPhysicalMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorTempPhysicalMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCoupleColorTempToLevelMinMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCoupleColorTempToLevelMinMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartUpColorTemperatureMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeStartUpColorTemperatureMiredsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeStartUpColorTemperatureMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class ContentLauncherCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1290L; + + public ContentLauncherCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void launchContentRequest( + LaunchResponseCallback callback, + Boolean autoPlay, + String data, + ArrayList search) { + launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, null); + } + + public void launchContentRequest( + LaunchResponseCallback callback, + Boolean autoPlay, + String data, + ArrayList search, + int timedInvokeTimeoutMs) { + launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, timedInvokeTimeoutMs); + } + + public void launchURLRequest( + LaunchResponseCallback callback, + String contentURL, + String displayString, + ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation) { + launchURLRequest( + chipClusterPtr, callback, contentURL, displayString, brandingInformation, null); + } + + public void launchURLRequest( + LaunchResponseCallback callback, + String contentURL, + String displayString, + ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation, + int timedInvokeTimeoutMs) { + launchURLRequest( + chipClusterPtr, + callback, + contentURL, + displayString, + brandingInformation, + timedInvokeTimeoutMs); + } + + private native void launchContentRequest( + long chipClusterPtr, + LaunchResponseCallback Callback, + Boolean autoPlay, + String data, + ArrayList search, + @Nullable Integer timedInvokeTimeoutMs); + + private native void launchURLRequest( + long chipClusterPtr, + LaunchResponseCallback Callback, + String contentURL, + String displayString, + ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation, + @Nullable Integer timedInvokeTimeoutMs); + + public interface LaunchResponseCallback { + void onSuccess(Integer status, String data); + + void onError(Exception error); + } + + public interface AcceptHeaderListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readAcceptHeaderListAttribute(AcceptHeaderListAttributeCallback callback) { + readAcceptHeaderListAttribute(chipClusterPtr, callback); + } + + public void subscribeAcceptHeaderListAttribute( + AcceptHeaderListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeAcceptHeaderListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedStreamingProtocolsAttribute(LongAttributeCallback callback) { + readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback); + } + + public void writeSupportedStreamingProtocolsAttribute( + DefaultClusterCallback callback, Long value) { + writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSupportedStreamingProtocolsAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeSupportedStreamingProtocolsAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + + public void subscribeSupportedStreamingProtocolsAttribute( + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeSupportedStreamingProtocolsAttribute( + 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 readClusterRevisionAttribute(IntegerAttributeCallback callback) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAcceptHeaderListAttribute(long chipClusterPtr, - AcceptHeaderListAttributeCallback callback - ); - private native void subscribeAcceptHeaderListAttribute(long chipClusterPtr, - AcceptHeaderListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readSupportedStreamingProtocolsAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeSupportedStreamingProtocolsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSupportedStreamingProtocolsAttribute(long chipClusterPtr, - LongAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readAcceptHeaderListAttribute( + long chipClusterPtr, AcceptHeaderListAttributeCallback callback); + + private native void subscribeAcceptHeaderListAttribute( + long chipClusterPtr, + AcceptHeaderListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSupportedStreamingProtocolsAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void writeSupportedStreamingProtocolsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSupportedStreamingProtocolsAttribute( + long chipClusterPtr, LongAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class DescriptorCluster extends BaseChipCluster { @@ -3846,145 +4436,147 @@ public DescriptorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface DeviceListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ServerListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ClientListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface PartsListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface DeviceListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ServerListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ClientListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface PartsListAttributeCallback { + void onSuccess(List valueList); - public void readDeviceListAttribute( - DeviceListAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readDeviceListAttribute(DeviceListAttributeCallback callback) { readDeviceListAttribute(chipClusterPtr, callback); } + public void subscribeDeviceListAttribute( - DeviceListAttributeCallback callback - , - int minInterval, int maxInterval) { + DeviceListAttributeCallback callback, int minInterval, int maxInterval) { subscribeDeviceListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readServerListAttribute( - ServerListAttributeCallback callback - ) { + public void readServerListAttribute(ServerListAttributeCallback callback) { readServerListAttribute(chipClusterPtr, callback); } + public void subscribeServerListAttribute( - ServerListAttributeCallback callback - , - int minInterval, int maxInterval) { + ServerListAttributeCallback callback, int minInterval, int maxInterval) { subscribeServerListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClientListAttribute( - ClientListAttributeCallback callback - ) { + public void readClientListAttribute(ClientListAttributeCallback callback) { readClientListAttribute(chipClusterPtr, callback); } + public void subscribeClientListAttribute( - ClientListAttributeCallback callback - , - int minInterval, int maxInterval) { + ClientListAttributeCallback callback, int minInterval, int maxInterval) { subscribeClientListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartsListAttribute( - PartsListAttributeCallback callback - ) { + public void readPartsListAttribute(PartsListAttributeCallback callback) { readPartsListAttribute(chipClusterPtr, callback); } + public void subscribePartsListAttribute( - PartsListAttributeCallback callback - , - int minInterval, int maxInterval) { + PartsListAttributeCallback callback, int minInterval, int maxInterval) { subscribePartsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readDeviceListAttribute(long chipClusterPtr, - DeviceListAttributeCallback callback - ); - private native void subscribeDeviceListAttribute(long chipClusterPtr, - DeviceListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readServerListAttribute(long chipClusterPtr, - ServerListAttributeCallback callback - ); - private native void subscribeServerListAttribute(long chipClusterPtr, - ServerListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readClientListAttribute(long chipClusterPtr, - ClientListAttributeCallback callback - ); - private native void subscribeClientListAttribute(long chipClusterPtr, - ClientListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readPartsListAttribute(long chipClusterPtr, - PartsListAttributeCallback callback - ); - private native void subscribePartsListAttribute(long chipClusterPtr, - PartsListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readDeviceListAttribute( + long chipClusterPtr, DeviceListAttributeCallback callback); + + private native void subscribeDeviceListAttribute( + long chipClusterPtr, + DeviceListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readServerListAttribute( + long chipClusterPtr, ServerListAttributeCallback callback); + + private native void subscribeServerListAttribute( + long chipClusterPtr, + ServerListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readClientListAttribute( + long chipClusterPtr, ClientListAttributeCallback callback); + + private native void subscribeClientListAttribute( + long chipClusterPtr, + ClientListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPartsListAttribute( + long chipClusterPtr, PartsListAttributeCallback callback); + + private native void subscribePartsListAttribute( + long chipClusterPtr, PartsListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class DiagnosticLogsCluster extends BaseChipCluster { @@ -3997,50 +4589,69 @@ public DiagnosticLogsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void retrieveLogsRequest(RetrieveLogsResponseCallback callback - , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator) { - retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null); - } + public void retrieveLogsRequest( + RetrieveLogsResponseCallback callback, + Integer intent, + Integer requestedProtocol, + byte[] transferFileDesignator) { + retrieveLogsRequest( + chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null); + } + + public void retrieveLogsRequest( + RetrieveLogsResponseCallback callback, + Integer intent, + Integer requestedProtocol, + byte[] transferFileDesignator, + int timedInvokeTimeoutMs) { + retrieveLogsRequest( + chipClusterPtr, + callback, + intent, + requestedProtocol, + transferFileDesignator, + timedInvokeTimeoutMs); + } + + private native void retrieveLogsRequest( + long chipClusterPtr, + RetrieveLogsResponseCallback Callback, + Integer intent, + Integer requestedProtocol, + byte[] transferFileDesignator, + @Nullable Integer timedInvokeTimeoutMs); - public void retrieveLogsRequest(RetrieveLogsResponseCallback callback - , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator - , int timedInvokeTimeoutMs) { - retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, timedInvokeTimeoutMs); - } - private native void retrieveLogsRequest(long chipClusterPtr, RetrieveLogsResponseCallback Callback - , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator - , @Nullable Integer timedInvokeTimeoutMs); public interface RetrieveLogsResponseCallback { void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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); } public static class DoorLockCluster extends BaseChipCluster { @@ -4053,733 +4664,886 @@ public DoorLockCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - - public void clearCredential(DefaultClusterCallback callback - , @Nullable ChipStructs.DoorLockClusterDlCredential credential - , int timedInvokeTimeoutMs) { + public void clearCredential( + DefaultClusterCallback callback, + @Nullable ChipStructs.DoorLockClusterDlCredential credential, + int timedInvokeTimeoutMs) { clearCredential(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); } - - public void clearUser(DefaultClusterCallback callback - , Integer userIndex - , int timedInvokeTimeoutMs) { + public void clearUser( + DefaultClusterCallback callback, Integer userIndex, int timedInvokeTimeoutMs) { clearUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); } - public void clearWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex) { + public void clearWeekDaySchedule( + DefaultClusterCallback callback, Integer weekDayIndex, Integer userIndex) { clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); } - public void clearWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void clearWeekDaySchedule( + DefaultClusterCallback callback, + Integer weekDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); } - public void clearYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex) { + public void clearYearDaySchedule( + DefaultClusterCallback callback, Integer yearDayIndex, Integer userIndex) { clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); } - public void clearYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void clearYearDaySchedule( + DefaultClusterCallback callback, + Integer yearDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); } - public void getCredentialStatus(GetCredentialStatusResponseCallback callback - , ChipStructs.DoorLockClusterDlCredential credential) { + public void getCredentialStatus( + GetCredentialStatusResponseCallback callback, + ChipStructs.DoorLockClusterDlCredential credential) { getCredentialStatus(chipClusterPtr, callback, credential, null); } - public void getCredentialStatus(GetCredentialStatusResponseCallback callback - , ChipStructs.DoorLockClusterDlCredential credential - , int timedInvokeTimeoutMs) { + public void getCredentialStatus( + GetCredentialStatusResponseCallback callback, + ChipStructs.DoorLockClusterDlCredential credential, + int timedInvokeTimeoutMs) { getCredentialStatus(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); } - public void getUser(GetUserResponseCallback callback - , Integer userIndex) { + public void getUser(GetUserResponseCallback callback, Integer userIndex) { getUser(chipClusterPtr, callback, userIndex, null); } - public void getUser(GetUserResponseCallback callback - , Integer userIndex - , int timedInvokeTimeoutMs) { + public void getUser( + GetUserResponseCallback callback, Integer userIndex, int timedInvokeTimeoutMs) { getUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); } - public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback - , Integer weekDayIndex, Integer userIndex) { + public void getWeekDaySchedule( + GetWeekDayScheduleResponseCallback callback, Integer weekDayIndex, Integer userIndex) { getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); } - public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback - , Integer weekDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void getWeekDaySchedule( + GetWeekDayScheduleResponseCallback callback, + Integer weekDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); } - public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback - , Integer yearDayIndex, Integer userIndex) { + public void getYearDaySchedule( + GetYearDayScheduleResponseCallback callback, Integer yearDayIndex, Integer userIndex) { getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); } - public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback - , Integer yearDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void getYearDaySchedule( + GetYearDayScheduleResponseCallback callback, + Integer yearDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); } - - public void lockDoor(DefaultClusterCallback callback - , Optional pinCode - , int timedInvokeTimeoutMs) { + public void lockDoor( + DefaultClusterCallback callback, Optional pinCode, int timedInvokeTimeoutMs) { lockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); } - - public void setCredential(SetCredentialResponseCallback callback - , Integer operationType, ChipStructs.DoorLockClusterDlCredential credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType - , int timedInvokeTimeoutMs) { - setCredential(chipClusterPtr, callback, operationType, credential, credentialData, userIndex, userStatus, userType, timedInvokeTimeoutMs); - } - - - public void setUser(DefaultClusterCallback callback - , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule - , int timedInvokeTimeoutMs) { - setUser(chipClusterPtr, callback, operationType, userIndex, userName, userUniqueId, userStatus, userType, credentialRule, timedInvokeTimeoutMs); - } - - public void setWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute) { - setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, null); - } - - public void setWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute - , int timedInvokeTimeoutMs) { - setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, timedInvokeTimeoutMs); - } - - public void setYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime) { - setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null); - } - - public void setYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime - , int timedInvokeTimeoutMs) { - setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, timedInvokeTimeoutMs); - } - - - public void unlockDoor(DefaultClusterCallback callback - , Optional pinCode - , int timedInvokeTimeoutMs) { + public void setCredential( + SetCredentialResponseCallback callback, + Integer operationType, + ChipStructs.DoorLockClusterDlCredential credential, + byte[] credentialData, + @Nullable Integer userIndex, + @Nullable Integer userStatus, + @Nullable Integer userType, + int timedInvokeTimeoutMs) { + setCredential( + chipClusterPtr, + callback, + operationType, + credential, + credentialData, + userIndex, + userStatus, + userType, + timedInvokeTimeoutMs); + } + + public void setUser( + DefaultClusterCallback callback, + Integer operationType, + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + int timedInvokeTimeoutMs) { + setUser( + chipClusterPtr, + callback, + operationType, + userIndex, + userName, + userUniqueId, + userStatus, + userType, + credentialRule, + timedInvokeTimeoutMs); + } + + public void setWeekDaySchedule( + DefaultClusterCallback callback, + Integer weekDayIndex, + Integer userIndex, + Integer daysMask, + Integer startHour, + Integer startMinute, + Integer endHour, + Integer endMinute) { + setWeekDaySchedule( + chipClusterPtr, + callback, + weekDayIndex, + userIndex, + daysMask, + startHour, + startMinute, + endHour, + endMinute, + null); + } + + public void setWeekDaySchedule( + DefaultClusterCallback callback, + Integer weekDayIndex, + Integer userIndex, + Integer daysMask, + Integer startHour, + Integer startMinute, + Integer endHour, + Integer endMinute, + int timedInvokeTimeoutMs) { + setWeekDaySchedule( + chipClusterPtr, + callback, + weekDayIndex, + userIndex, + daysMask, + startHour, + startMinute, + endHour, + endMinute, + timedInvokeTimeoutMs); + } + + public void setYearDaySchedule( + DefaultClusterCallback callback, + Integer yearDayIndex, + Integer userIndex, + Long localStartTime, + Long localEndTime) { + setYearDaySchedule( + chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null); + } + + public void setYearDaySchedule( + DefaultClusterCallback callback, + Integer yearDayIndex, + Integer userIndex, + Long localStartTime, + Long localEndTime, + int timedInvokeTimeoutMs) { + setYearDaySchedule( + chipClusterPtr, + callback, + yearDayIndex, + userIndex, + localStartTime, + localEndTime, + timedInvokeTimeoutMs); + } + + public void unlockDoor( + DefaultClusterCallback callback, Optional pinCode, int timedInvokeTimeoutMs) { unlockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); } - - public void unlockWithTimeout(DefaultClusterCallback callback - , Integer timeout, Optional pinCode - , int timedInvokeTimeoutMs) { + public void unlockWithTimeout( + DefaultClusterCallback callback, + Integer timeout, + Optional pinCode, + int timedInvokeTimeoutMs) { unlockWithTimeout(chipClusterPtr, callback, timeout, pinCode, timedInvokeTimeoutMs); } - private native void clearCredential(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable ChipStructs.DoorLockClusterDlCredential credential - , @Nullable Integer timedInvokeTimeoutMs); - private native void clearUser(long chipClusterPtr, DefaultClusterCallback Callback - , Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void clearWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer weekDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void clearYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer yearDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void getCredentialStatus(long chipClusterPtr, GetCredentialStatusResponseCallback Callback - , ChipStructs.DoorLockClusterDlCredential credential - , @Nullable Integer timedInvokeTimeoutMs); - private native void getUser(long chipClusterPtr, GetUserResponseCallback Callback - , Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void getWeekDaySchedule(long chipClusterPtr, GetWeekDayScheduleResponseCallback Callback - , Integer weekDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void getYearDaySchedule(long chipClusterPtr, GetYearDayScheduleResponseCallback Callback - , Integer yearDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void lockDoor(long chipClusterPtr, DefaultClusterCallback Callback - , Optional pinCode - , @Nullable Integer timedInvokeTimeoutMs); - private native void setCredential(long chipClusterPtr, SetCredentialResponseCallback Callback - , Integer operationType, ChipStructs.DoorLockClusterDlCredential credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType - , @Nullable Integer timedInvokeTimeoutMs); - private native void setUser(long chipClusterPtr, DefaultClusterCallback Callback - , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule - , @Nullable Integer timedInvokeTimeoutMs); - private native void setWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute - , @Nullable Integer timedInvokeTimeoutMs); - private native void setYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void unlockDoor(long chipClusterPtr, DefaultClusterCallback Callback - , Optional pinCode - , @Nullable Integer timedInvokeTimeoutMs); - private native void unlockWithTimeout(long chipClusterPtr, DefaultClusterCallback Callback - , Integer timeout, Optional pinCode - , @Nullable Integer timedInvokeTimeoutMs); + + private native void clearCredential( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable ChipStructs.DoorLockClusterDlCredential credential, + @Nullable Integer timedInvokeTimeoutMs); + + private native void clearUser( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void clearWeekDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer weekDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void clearYearDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer yearDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getCredentialStatus( + long chipClusterPtr, + GetCredentialStatusResponseCallback Callback, + ChipStructs.DoorLockClusterDlCredential credential, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getUser( + long chipClusterPtr, + GetUserResponseCallback Callback, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getWeekDaySchedule( + long chipClusterPtr, + GetWeekDayScheduleResponseCallback Callback, + Integer weekDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getYearDaySchedule( + long chipClusterPtr, + GetYearDayScheduleResponseCallback Callback, + Integer yearDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void lockDoor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Optional pinCode, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setCredential( + long chipClusterPtr, + SetCredentialResponseCallback Callback, + Integer operationType, + ChipStructs.DoorLockClusterDlCredential credential, + byte[] credentialData, + @Nullable Integer userIndex, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setUser( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer operationType, + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setWeekDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer weekDayIndex, + Integer userIndex, + Integer daysMask, + Integer startHour, + Integer startMinute, + Integer endHour, + Integer endMinute, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setYearDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer yearDayIndex, + Integer userIndex, + Long localStartTime, + Long localEndTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void unlockDoor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Optional pinCode, + @Nullable Integer timedInvokeTimeoutMs); + + private native void unlockWithTimeout( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer timeout, + Optional pinCode, + @Nullable Integer timedInvokeTimeoutMs); + public interface GetCredentialStatusResponseCallback { - void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); + void onSuccess( + Boolean credentialExists, + @Nullable Integer userIndex, + @Nullable Integer nextCredentialIndex); void onError(Exception error); } public interface GetUserResponseCallback { - void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex); + void onSuccess( + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + @Nullable ArrayList credentials, + @Nullable Integer creatorFabricIndex, + @Nullable Integer lastModifiedFabricIndex, + @Nullable Integer nextUserIndex); void onError(Exception error); } public interface GetWeekDayScheduleResponseCallback { - void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute); + void onSuccess( + Integer weekDayIndex, + Integer userIndex, + Integer status, + Optional daysMask, + Optional startHour, + Optional startMinute, + Optional endHour, + Optional endMinute); void onError(Exception error); } public interface GetYearDayScheduleResponseCallback { - void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime); + void onSuccess( + Integer yearDayIndex, + Integer userIndex, + Integer status, + Optional localStartTime, + Optional localEndTime); void onError(Exception error); } public interface SetCredentialResponseCallback { - void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); + void onSuccess( + Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); void onError(Exception error); } + public interface LockStateAttributeCallback { + void onSuccess(@Nullable Integer value); - public interface LockStateAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface DoorStateAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); - public void readLockStateAttribute( - LockStateAttributeCallback callback - ) { - readLockStateAttribute(chipClusterPtr, callback); + default void onSubscriptionEstablished() {} } - public void subscribeLockStateAttribute( - LockStateAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeLockStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + + public interface DoorStateAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void readLockTypeAttribute( - IntegerAttributeCallback callback - ) { - readLockTypeAttribute(chipClusterPtr, callback); + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } + + public void readLockStateAttribute(LockStateAttributeCallback callback) { + readLockStateAttribute(chipClusterPtr, callback); + } + + public void subscribeLockStateAttribute( + LockStateAttributeCallback callback, int minInterval, int maxInterval) { + subscribeLockStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLockTypeAttribute(IntegerAttributeCallback callback) { + readLockTypeAttribute(chipClusterPtr, callback); + } + public void subscribeLockTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLockTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActuatorEnabledAttribute( - BooleanAttributeCallback callback - ) { + public void readActuatorEnabledAttribute(BooleanAttributeCallback callback) { readActuatorEnabledAttribute(chipClusterPtr, callback); } + public void subscribeActuatorEnabledAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeActuatorEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDoorStateAttribute( - DoorStateAttributeCallback callback - ) { + public void readDoorStateAttribute(DoorStateAttributeCallback callback) { readDoorStateAttribute(chipClusterPtr, callback); } + public void subscribeDoorStateAttribute( - DoorStateAttributeCallback callback - , - int minInterval, int maxInterval) { + DoorStateAttributeCallback callback, int minInterval, int maxInterval) { subscribeDoorStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfTotalUsersSupportedAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfTotalUsersSupportedAttribute(IntegerAttributeCallback callback) { readNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfTotalUsersSupportedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfTotalUsersSupportedAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfPINUsersSupportedAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfPINUsersSupportedAttribute(IntegerAttributeCallback callback) { readNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfPINUsersSupportedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfPINUsersSupportedAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfRFIDUsersSupportedAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfRFIDUsersSupportedAttribute(IntegerAttributeCallback callback) { readNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfRFIDUsersSupportedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfRFIDUsersSupportedAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNumberOfWeekDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback - ) { + IntegerAttributeCallback callback) { readNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNumberOfYearDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback - ) { + IntegerAttributeCallback callback) { readNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxPINCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxPINCodeLengthAttribute(IntegerAttributeCallback callback) { readMaxPINCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMaxPINCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinPINCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMinPINCodeLengthAttribute(IntegerAttributeCallback callback) { readMinPINCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMinPINCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxRFIDCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxRFIDCodeLengthAttribute(IntegerAttributeCallback callback) { readMaxRFIDCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMaxRFIDCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinRFIDCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMinRFIDCodeLengthAttribute(IntegerAttributeCallback callback) { readMinRFIDCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMinRFIDCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLanguageAttribute( - CharStringAttributeCallback callback - ) { + public void readLanguageAttribute(CharStringAttributeCallback callback) { readLanguageAttribute(chipClusterPtr, callback); } + public void writeLanguageAttribute(DefaultClusterCallback callback, String value) { writeLanguageAttribute(chipClusterPtr, callback, value, null); } - public void writeLanguageAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLanguageAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLanguageAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLanguageAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLanguageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAutoRelockTimeAttribute( - LongAttributeCallback callback - ) { + public void readAutoRelockTimeAttribute(LongAttributeCallback callback) { readAutoRelockTimeAttribute(chipClusterPtr, callback); } + public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value) { writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeAutoRelockTimeAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeAutoRelockTimeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeAutoRelockTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoundVolumeAttribute( - IntegerAttributeCallback callback - ) { + public void readSoundVolumeAttribute(IntegerAttributeCallback callback) { readSoundVolumeAttribute(chipClusterPtr, callback); } + public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value) { writeSoundVolumeAttribute(chipClusterPtr, callback, value, null); } - public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSoundVolumeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSoundVolumeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeSoundVolumeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSoundVolumeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperatingModeAttribute( - IntegerAttributeCallback callback - ) { + public void readOperatingModeAttribute(IntegerAttributeCallback callback) { readOperatingModeAttribute(chipClusterPtr, callback); } + public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value) { writeOperatingModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOperatingModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOperatingModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOperatingModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOperatingModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedOperatingModesAttribute( - IntegerAttributeCallback callback - ) { + public void readSupportedOperatingModesAttribute(IntegerAttributeCallback callback) { readSupportedOperatingModesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedOperatingModesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedOperatingModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnableOneTouchLockingAttribute( - BooleanAttributeCallback callback - ) { + public void readEnableOneTouchLockingAttribute(BooleanAttributeCallback callback) { readEnableOneTouchLockingAttribute(chipClusterPtr, callback); } - public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value) { + + public void writeEnableOneTouchLockingAttribute( + DefaultClusterCallback callback, Boolean value) { writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, null); } - public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeEnableOneTouchLockingAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnableOneTouchLockingAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnableOneTouchLockingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnablePrivacyModeButtonAttribute( - BooleanAttributeCallback callback - ) { + public void readEnablePrivacyModeButtonAttribute(BooleanAttributeCallback callback) { readEnablePrivacyModeButtonAttribute(chipClusterPtr, callback); } - public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value) { + + public void writeEnablePrivacyModeButtonAttribute( + DefaultClusterCallback callback, Boolean value) { writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, null); } - public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeEnablePrivacyModeButtonAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnablePrivacyModeButtonAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWrongCodeEntryLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readWrongCodeEntryLimitAttribute(IntegerAttributeCallback callback) { readWrongCodeEntryLimitAttribute(chipClusterPtr, callback); } + public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value) { writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWrongCodeEntryLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeWrongCodeEntryLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLockStateAttribute(long chipClusterPtr, - LockStateAttributeCallback callback - ); - private native void subscribeLockStateAttribute(long chipClusterPtr, - LockStateAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readLockTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLockTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActuatorEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeActuatorEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDoorStateAttribute(long chipClusterPtr, - DoorStateAttributeCallback callback - ); - private native void subscribeDoorStateAttribute(long chipClusterPtr, - DoorStateAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfPINUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfPINUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLanguageAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeLanguageAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLanguageAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAutoRelockTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeAutoRelockTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeAutoRelockTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSoundVolumeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeSoundVolumeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSoundVolumeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOperatingModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOperatingModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOperatingModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedOperatingModesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSupportedOperatingModesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnableOneTouchLockingAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeEnableOneTouchLockingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnableOneTouchLockingAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnablePrivacyModeButtonAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeEnablePrivacyModeButtonAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnablePrivacyModeButtonAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWrongCodeEntryLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeWrongCodeEntryLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeWrongCodeEntryLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readLockStateAttribute( + long chipClusterPtr, LockStateAttributeCallback callback); + + private native void subscribeLockStateAttribute( + long chipClusterPtr, LockStateAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLockTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLockTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActuatorEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeActuatorEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDoorStateAttribute( + long chipClusterPtr, DoorStateAttributeCallback callback); + + private native void subscribeDoorStateAttribute( + long chipClusterPtr, DoorStateAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfTotalUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfTotalUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfPINUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfPINUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfRFIDUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfRFIDUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfWeekDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfYearDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLanguageAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeLanguageAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLanguageAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readAutoRelockTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void writeAutoRelockTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeAutoRelockTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSoundVolumeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeSoundVolumeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSoundVolumeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOperatingModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOperatingModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOperatingModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSupportedOperatingModesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSupportedOperatingModesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnableOneTouchLockingAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeEnableOneTouchLockingAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnableOneTouchLockingAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnablePrivacyModeButtonAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeEnablePrivacyModeButtonAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnablePrivacyModeButtonAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWrongCodeEntryLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeWrongCodeEntryLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeWrongCodeEntryLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ElectricalMeasurementCluster extends BaseChipCluster { @@ -4792,258 +5556,211 @@ public ElectricalMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readMeasurementTypeAttribute( - LongAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMeasurementTypeAttribute(LongAttributeCallback callback) { readMeasurementTypeAttribute(chipClusterPtr, callback); } + public void subscribeMeasurementTypeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasurementTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTotalActivePowerAttribute( - LongAttributeCallback callback - ) { + public void readTotalActivePowerAttribute(LongAttributeCallback callback) { readTotalActivePowerAttribute(chipClusterPtr, callback); } + public void subscribeTotalActivePowerAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTotalActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsVoltageAttribute(IntegerAttributeCallback callback) { readRmsVoltageAttribute(chipClusterPtr, callback); } + public void subscribeRmsVoltageAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageMinAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsVoltageMinAttribute(IntegerAttributeCallback callback) { readRmsVoltageMinAttribute(chipClusterPtr, callback); } + public void subscribeRmsVoltageMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsVoltageMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsVoltageMaxAttribute(IntegerAttributeCallback callback) { readRmsVoltageMaxAttribute(chipClusterPtr, callback); } + public void subscribeRmsVoltageMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsVoltageMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsCurrentAttribute(IntegerAttributeCallback callback) { readRmsCurrentAttribute(chipClusterPtr, callback); } + public void subscribeRmsCurrentAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentMinAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsCurrentMinAttribute(IntegerAttributeCallback callback) { readRmsCurrentMinAttribute(chipClusterPtr, callback); } + public void subscribeRmsCurrentMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsCurrentMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsCurrentMaxAttribute(IntegerAttributeCallback callback) { readRmsCurrentMaxAttribute(chipClusterPtr, callback); } + public void subscribeRmsCurrentMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsCurrentMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerAttribute( - IntegerAttributeCallback callback - ) { + public void readActivePowerAttribute(IntegerAttributeCallback callback) { readActivePowerAttribute(chipClusterPtr, callback); } + public void subscribeActivePowerAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerMinAttribute( - IntegerAttributeCallback callback - ) { + public void readActivePowerMinAttribute(IntegerAttributeCallback callback) { readActivePowerMinAttribute(chipClusterPtr, callback); } + public void subscribeActivePowerMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActivePowerMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readActivePowerMaxAttribute(IntegerAttributeCallback callback) { readActivePowerMaxAttribute(chipClusterPtr, callback); } + public void subscribeActivePowerMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActivePowerMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasurementTypeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeMeasurementTypeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTotalActivePowerAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTotalActivePowerAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsVoltageAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsVoltageAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsVoltageMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsVoltageMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsVoltageMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsVoltageMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsCurrentAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsCurrentAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsCurrentMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsCurrentMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsCurrentMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsCurrentMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActivePowerAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeActivePowerAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActivePowerMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeActivePowerMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActivePowerMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeActivePowerMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasurementTypeAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeMeasurementTypeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTotalActivePowerAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTotalActivePowerAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsVoltageAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsVoltageAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsVoltageMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsVoltageMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsVoltageMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsVoltageMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsCurrentAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsCurrentAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsCurrentMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsCurrentMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsCurrentMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsCurrentMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActivePowerAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeActivePowerAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActivePowerMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeActivePowerMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActivePowerMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeActivePowerMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class EthernetNetworkDiagnosticsCluster extends BaseChipCluster { @@ -5056,253 +5773,210 @@ public EthernetNetworkDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetCounts(DefaultClusterCallback callback - ) { + public void resetCounts(DefaultClusterCallback callback) { resetCounts(chipClusterPtr, callback, null); } - public void resetCounts(DefaultClusterCallback callback + public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void resetCounts( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readPHYRateAttribute( - IntegerAttributeCallback callback - ) { + public void readPHYRateAttribute(IntegerAttributeCallback callback) { readPHYRateAttribute(chipClusterPtr, callback); } + public void subscribePHYRateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePHYRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFullDuplexAttribute( - BooleanAttributeCallback callback - ) { + public void readFullDuplexAttribute(BooleanAttributeCallback callback) { readFullDuplexAttribute(chipClusterPtr, callback); } + public void subscribeFullDuplexAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeFullDuplexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketRxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketRxCountAttribute(LongAttributeCallback callback) { readPacketRxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketTxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketTxCountAttribute(LongAttributeCallback callback) { readPacketTxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketTxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrCountAttribute(LongAttributeCallback callback) { readTxErrCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCollisionCountAttribute( - LongAttributeCallback callback - ) { + public void readCollisionCountAttribute(LongAttributeCallback callback) { readCollisionCountAttribute(chipClusterPtr, callback); } + public void subscribeCollisionCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCollisionCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute( - LongAttributeCallback callback - ) { + public void readOverrunCountAttribute(LongAttributeCallback callback) { readOverrunCountAttribute(chipClusterPtr, callback); } + public void subscribeOverrunCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCarrierDetectAttribute( - BooleanAttributeCallback callback - ) { + public void readCarrierDetectAttribute(BooleanAttributeCallback callback) { readCarrierDetectAttribute(chipClusterPtr, callback); } + public void subscribeCarrierDetectAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeCarrierDetectAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTimeSinceResetAttribute( - LongAttributeCallback callback - ) { + public void readTimeSinceResetAttribute(LongAttributeCallback callback) { readTimeSinceResetAttribute(chipClusterPtr, callback); } + public void subscribeTimeSinceResetAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTimeSinceResetAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readPHYRateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePHYRateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readFullDuplexAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeFullDuplexAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCollisionCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCollisionCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCarrierDetectAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeCarrierDetectAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTimeSinceResetAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTimeSinceResetAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readPHYRateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePHYRateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFullDuplexAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeFullDuplexAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCollisionCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCollisionCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCarrierDetectAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeCarrierDetectAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTimeSinceResetAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTimeSinceResetAttribute( + long chipClusterPtr, LongAttributeCallback 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 FixedLabelCluster extends BaseChipCluster { @@ -5315,73 +5989,69 @@ public FixedLabelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LabelListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface LabelListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readLabelListAttribute( - LabelListAttributeCallback callback - ) { + public void readLabelListAttribute(LabelListAttributeCallback callback) { readLabelListAttribute(chipClusterPtr, callback); } + public void subscribeLabelListAttribute( - LabelListAttributeCallback callback - , - int minInterval, int maxInterval) { + LabelListAttributeCallback callback, int minInterval, int maxInterval) { subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback callback - ); - private native void subscribeLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback callback); + + private native void subscribeLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class FlowMeasurementCluster extends BaseChipCluster { @@ -5394,125 +6064,106 @@ public FlowMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { + public void readToleranceAttribute(IntegerAttributeCallback callback) { readToleranceAttribute(chipClusterPtr, callback); } + public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GeneralCommissioningCluster extends BaseChipCluster { @@ -5525,47 +6176,88 @@ public GeneralCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void armFailSafe(ArmFailSafeResponseCallback callback - , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs) { + public void armFailSafe( + ArmFailSafeResponseCallback callback, + Integer expiryLengthSeconds, + Long breadcrumb, + Long timeoutMs) { armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timeoutMs, null); } - public void armFailSafe(ArmFailSafeResponseCallback callback - , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs - , int timedInvokeTimeoutMs) { - armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timeoutMs, timedInvokeTimeoutMs); + public void armFailSafe( + ArmFailSafeResponseCallback callback, + Integer expiryLengthSeconds, + Long breadcrumb, + Long timeoutMs, + int timedInvokeTimeoutMs) { + armFailSafe( + chipClusterPtr, + callback, + expiryLengthSeconds, + breadcrumb, + timeoutMs, + timedInvokeTimeoutMs); } - public void commissioningComplete(CommissioningCompleteResponseCallback callback - ) { + public void commissioningComplete(CommissioningCompleteResponseCallback callback) { commissioningComplete(chipClusterPtr, callback, null); } - public void commissioningComplete(CommissioningCompleteResponseCallback callback + public void commissioningComplete( + CommissioningCompleteResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { commissioningComplete(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback - , Integer location, String countryCode, Long breadcrumb, Long timeoutMs) { - setRegulatoryConfig(chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, null); - } - - public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback - , Integer location, String countryCode, Long breadcrumb, Long timeoutMs - , int timedInvokeTimeoutMs) { - setRegulatoryConfig(chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, timedInvokeTimeoutMs); - } - private native void armFailSafe(long chipClusterPtr, ArmFailSafeResponseCallback Callback - , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs - , @Nullable Integer timedInvokeTimeoutMs); - private native void commissioningComplete(long chipClusterPtr, CommissioningCompleteResponseCallback Callback + public void setRegulatoryConfig( + SetRegulatoryConfigResponseCallback callback, + Integer location, + String countryCode, + Long breadcrumb, + Long timeoutMs) { + setRegulatoryConfig( + chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, null); + } + + public void setRegulatoryConfig( + SetRegulatoryConfigResponseCallback callback, + Integer location, + String countryCode, + Long breadcrumb, + Long timeoutMs, + int timedInvokeTimeoutMs) { + setRegulatoryConfig( + chipClusterPtr, + callback, + location, + countryCode, + breadcrumb, + timeoutMs, + timedInvokeTimeoutMs); + } + + private native void armFailSafe( + long chipClusterPtr, + ArmFailSafeResponseCallback Callback, + Integer expiryLengthSeconds, + Long breadcrumb, + Long timeoutMs, + @Nullable Integer timedInvokeTimeoutMs); + + private native void commissioningComplete( + long chipClusterPtr, + CommissioningCompleteResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setRegulatoryConfig( + long chipClusterPtr, + SetRegulatoryConfigResponseCallback Callback, + Integer location, + String countryCode, + Long breadcrumb, + Long timeoutMs, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void setRegulatoryConfig(long chipClusterPtr, SetRegulatoryConfigResponseCallback Callback - , Integer location, String countryCode, Long breadcrumb, Long timeoutMs - , @Nullable Integer timedInvokeTimeoutMs); public interface ArmFailSafeResponseCallback { void onSuccess(Integer errorCode, String debugText); @@ -5584,140 +6276,135 @@ public interface SetRegulatoryConfigResponseCallback { void onError(Exception error); } + public interface BasicCommissioningInfoListAttributeCallback { + void onSuccess( + List valueList); - public interface BasicCommissioningInfoListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readBreadcrumbAttribute( - LongAttributeCallback callback - ) { + public void readBreadcrumbAttribute(LongAttributeCallback callback) { readBreadcrumbAttribute(chipClusterPtr, callback); } + public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value) { writeBreadcrumbAttribute(chipClusterPtr, callback, value, null); } - public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBreadcrumbAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBreadcrumbAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBreadcrumbAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBreadcrumbAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readBasicCommissioningInfoListAttribute( - BasicCommissioningInfoListAttributeCallback callback - ) { + BasicCommissioningInfoListAttributeCallback callback) { readBasicCommissioningInfoListAttribute(chipClusterPtr, callback); } + public void subscribeBasicCommissioningInfoListAttribute( - BasicCommissioningInfoListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeBasicCommissioningInfoListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + BasicCommissioningInfoListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeBasicCommissioningInfoListAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readRegulatoryConfigAttribute( - IntegerAttributeCallback callback - ) { + public void readRegulatoryConfigAttribute(IntegerAttributeCallback callback) { readRegulatoryConfigAttribute(chipClusterPtr, callback); } + public void subscribeRegulatoryConfigAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRegulatoryConfigAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocationCapabilityAttribute( - IntegerAttributeCallback callback - ) { + public void readLocationCapabilityAttribute(IntegerAttributeCallback callback) { readLocationCapabilityAttribute(chipClusterPtr, callback); } + public void subscribeLocationCapabilityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocationCapabilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBreadcrumbAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeBreadcrumbAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBreadcrumbAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBasicCommissioningInfoListAttribute(long chipClusterPtr, - BasicCommissioningInfoListAttributeCallback callback - ); - private native void subscribeBasicCommissioningInfoListAttribute(long chipClusterPtr, - BasicCommissioningInfoListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readRegulatoryConfigAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRegulatoryConfigAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLocationCapabilityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLocationCapabilityAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readBreadcrumbAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void writeBreadcrumbAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBreadcrumbAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBasicCommissioningInfoListAttribute( + long chipClusterPtr, BasicCommissioningInfoListAttributeCallback callback); + + private native void subscribeBasicCommissioningInfoListAttribute( + long chipClusterPtr, + BasicCommissioningInfoListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readRegulatoryConfigAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRegulatoryConfigAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLocationCapabilityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLocationCapabilityAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GeneralDiagnosticsCluster extends BaseChipCluster { @@ -5730,221 +6417,209 @@ public GeneralDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface NetworkInterfacesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveHardwareFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveRadioFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveNetworkFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface NetworkInterfacesAttributeCallback { + void onSuccess(List valueList); - public void readNetworkInterfacesAttribute( - NetworkInterfacesAttributeCallback callback - ) { - readNetworkInterfacesAttribute(chipClusterPtr, callback); - } - public void subscribeNetworkInterfacesAttribute( - NetworkInterfacesAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + void onError(Exception ex); - public void readRebootCountAttribute( - IntegerAttributeCallback callback - ) { - readRebootCountAttribute(chipClusterPtr, callback); + default void onSubscriptionEstablished() {} } - public void subscribeRebootCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeRebootCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + + public interface ActiveHardwareFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void readUpTimeAttribute( - LongAttributeCallback callback - ) { + public interface ActiveRadioFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ActiveNetworkFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readNetworkInterfacesAttribute(NetworkInterfacesAttributeCallback callback) { + readNetworkInterfacesAttribute(chipClusterPtr, callback); + } + + public void subscribeNetworkInterfacesAttribute( + NetworkInterfacesAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRebootCountAttribute(IntegerAttributeCallback callback) { + readRebootCountAttribute(chipClusterPtr, callback); + } + + public void subscribeRebootCountAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeRebootCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUpTimeAttribute(LongAttributeCallback callback) { readUpTimeAttribute(chipClusterPtr, callback); } + public void subscribeUpTimeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTotalOperationalHoursAttribute( - LongAttributeCallback callback - ) { + public void readTotalOperationalHoursAttribute(LongAttributeCallback callback) { readTotalOperationalHoursAttribute(chipClusterPtr, callback); } + public void subscribeTotalOperationalHoursAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTotalOperationalHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBootReasonsAttribute( - IntegerAttributeCallback callback - ) { + public void readBootReasonsAttribute(IntegerAttributeCallback callback) { readBootReasonsAttribute(chipClusterPtr, callback); } + public void subscribeBootReasonsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBootReasonsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveHardwareFaultsAttribute( - ActiveHardwareFaultsAttributeCallback callback - ) { + public void readActiveHardwareFaultsAttribute(ActiveHardwareFaultsAttributeCallback callback) { readActiveHardwareFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveHardwareFaultsAttribute( - ActiveHardwareFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveHardwareFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveHardwareFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveRadioFaultsAttribute( - ActiveRadioFaultsAttributeCallback callback - ) { + public void readActiveRadioFaultsAttribute(ActiveRadioFaultsAttributeCallback callback) { readActiveRadioFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveRadioFaultsAttribute( - ActiveRadioFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveRadioFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveRadioFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveNetworkFaultsAttribute( - ActiveNetworkFaultsAttributeCallback callback - ) { + public void readActiveNetworkFaultsAttribute(ActiveNetworkFaultsAttributeCallback callback) { readActiveNetworkFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveNetworkFaultsAttribute( - ActiveNetworkFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveNetworkFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveNetworkFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNetworkInterfacesAttribute(long chipClusterPtr, - NetworkInterfacesAttributeCallback callback - ); - private native void subscribeNetworkInterfacesAttribute(long chipClusterPtr, - NetworkInterfacesAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readRebootCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRebootCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUpTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeUpTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTotalOperationalHoursAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTotalOperationalHoursAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBootReasonsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBootReasonsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveHardwareFaultsAttribute(long chipClusterPtr, - ActiveHardwareFaultsAttributeCallback callback - ); - private native void subscribeActiveHardwareFaultsAttribute(long chipClusterPtr, - ActiveHardwareFaultsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readActiveRadioFaultsAttribute(long chipClusterPtr, - ActiveRadioFaultsAttributeCallback callback - ); - private native void subscribeActiveRadioFaultsAttribute(long chipClusterPtr, - ActiveRadioFaultsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readActiveNetworkFaultsAttribute(long chipClusterPtr, - ActiveNetworkFaultsAttributeCallback callback - ); - private native void subscribeActiveNetworkFaultsAttribute(long chipClusterPtr, - ActiveNetworkFaultsAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readNetworkInterfacesAttribute( + long chipClusterPtr, NetworkInterfacesAttributeCallback callback); + + private native void subscribeNetworkInterfacesAttribute( + long chipClusterPtr, + NetworkInterfacesAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readRebootCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRebootCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUpTimeAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeUpTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTotalOperationalHoursAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTotalOperationalHoursAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBootReasonsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBootReasonsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveHardwareFaultsAttribute( + long chipClusterPtr, ActiveHardwareFaultsAttributeCallback callback); + + private native void subscribeActiveHardwareFaultsAttribute( + long chipClusterPtr, + ActiveHardwareFaultsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readActiveRadioFaultsAttribute( + long chipClusterPtr, ActiveRadioFaultsAttributeCallback callback); + + private native void subscribeActiveRadioFaultsAttribute( + long chipClusterPtr, + ActiveRadioFaultsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readActiveNetworkFaultsAttribute( + long chipClusterPtr, ActiveNetworkFaultsAttributeCallback callback); + + private native void subscribeActiveNetworkFaultsAttribute( + long chipClusterPtr, + ActiveNetworkFaultsAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GroupKeyManagementCluster extends BaseChipCluster { @@ -5957,61 +6632,73 @@ public GroupKeyManagementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void keySetRead(KeySetReadResponseCallback callback - , Integer groupKeySetID) { + public void keySetRead(KeySetReadResponseCallback callback, Integer groupKeySetID) { keySetRead(chipClusterPtr, callback, groupKeySetID, null); } - public void keySetRead(KeySetReadResponseCallback callback - , Integer groupKeySetID - , int timedInvokeTimeoutMs) { + public void keySetRead( + KeySetReadResponseCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) { keySetRead(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); } - public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback - , ArrayList groupKeySetIDs) { + public void keySetReadAllIndices( + KeySetReadAllIndicesResponseCallback callback, ArrayList groupKeySetIDs) { keySetReadAllIndices(chipClusterPtr, callback, groupKeySetIDs, null); } - public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback - , ArrayList groupKeySetIDs - , int timedInvokeTimeoutMs) { + public void keySetReadAllIndices( + KeySetReadAllIndicesResponseCallback callback, + ArrayList groupKeySetIDs, + int timedInvokeTimeoutMs) { keySetReadAllIndices(chipClusterPtr, callback, groupKeySetIDs, timedInvokeTimeoutMs); } - public void keySetRemove(DefaultClusterCallback callback - , Integer groupKeySetID) { + public void keySetRemove(DefaultClusterCallback callback, Integer groupKeySetID) { keySetRemove(chipClusterPtr, callback, groupKeySetID, null); } - public void keySetRemove(DefaultClusterCallback callback - , Integer groupKeySetID - , int timedInvokeTimeoutMs) { + public void keySetRemove( + DefaultClusterCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) { keySetRemove(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); } - public void keySetWrite(DefaultClusterCallback callback - , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { + public void keySetWrite( + DefaultClusterCallback callback, + ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { keySetWrite(chipClusterPtr, callback, groupKeySet, null); } - public void keySetWrite(DefaultClusterCallback callback - , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet - , int timedInvokeTimeoutMs) { + public void keySetWrite( + DefaultClusterCallback callback, + ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet, + int timedInvokeTimeoutMs) { keySetWrite(chipClusterPtr, callback, groupKeySet, timedInvokeTimeoutMs); } - private native void keySetRead(long chipClusterPtr, KeySetReadResponseCallback Callback - , Integer groupKeySetID - , @Nullable Integer timedInvokeTimeoutMs); - private native void keySetReadAllIndices(long chipClusterPtr, KeySetReadAllIndicesResponseCallback Callback - , ArrayList groupKeySetIDs - , @Nullable Integer timedInvokeTimeoutMs); - private native void keySetRemove(long chipClusterPtr, DefaultClusterCallback Callback - , Integer groupKeySetID - , @Nullable Integer timedInvokeTimeoutMs); - private native void keySetWrite(long chipClusterPtr, DefaultClusterCallback Callback - , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet - , @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetRead( + long chipClusterPtr, + KeySetReadResponseCallback Callback, + Integer groupKeySetID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetReadAllIndices( + long chipClusterPtr, + KeySetReadAllIndicesResponseCallback Callback, + ArrayList groupKeySetIDs, + @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetRemove( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer groupKeySetID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetWrite( + long chipClusterPtr, + DefaultClusterCallback Callback, + ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet, + @Nullable Integer timedInvokeTimeoutMs); + public interface KeySetReadAllIndicesResponseCallback { void onSuccess(ArrayList groupKeySetIDs); @@ -6024,136 +6711,128 @@ public interface KeySetReadResponseCallback { void onError(Exception error); } + public interface GroupKeyMapAttributeCallback { + void onSuccess(List valueList); - public interface GroupKeyMapAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface GroupTableAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface GroupTableAttributeCallback { + void onSuccess(List valueList); - public void readGroupKeyMapAttribute( - GroupKeyMapAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readGroupKeyMapAttribute(GroupKeyMapAttributeCallback callback) { readGroupKeyMapAttribute(chipClusterPtr, callback); } + public void subscribeGroupKeyMapAttribute( - GroupKeyMapAttributeCallback callback - , - int minInterval, int maxInterval) { + GroupKeyMapAttributeCallback callback, int minInterval, int maxInterval) { subscribeGroupKeyMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGroupTableAttribute( - GroupTableAttributeCallback callback - ) { + public void readGroupTableAttribute(GroupTableAttributeCallback callback) { readGroupTableAttribute(chipClusterPtr, callback); } + public void subscribeGroupTableAttribute( - GroupTableAttributeCallback callback - , - int minInterval, int maxInterval) { + GroupTableAttributeCallback callback, int minInterval, int maxInterval) { subscribeGroupTableAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxGroupsPerFabricAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxGroupsPerFabricAttribute(IntegerAttributeCallback callback) { readMaxGroupsPerFabricAttribute(chipClusterPtr, callback); } + public void subscribeMaxGroupsPerFabricAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxGroupsPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxGroupKeysPerFabricAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxGroupKeysPerFabricAttribute(IntegerAttributeCallback callback) { readMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback); } + public void subscribeMaxGroupKeysPerFabricAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readGroupKeyMapAttribute(long chipClusterPtr, - GroupKeyMapAttributeCallback callback - ); - private native void subscribeGroupKeyMapAttribute(long chipClusterPtr, - GroupKeyMapAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readGroupTableAttribute(long chipClusterPtr, - GroupTableAttributeCallback callback - ); - private native void subscribeGroupTableAttribute(long chipClusterPtr, - GroupTableAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readMaxGroupsPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxGroupsPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxGroupKeysPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxGroupKeysPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readGroupKeyMapAttribute( + long chipClusterPtr, GroupKeyMapAttributeCallback callback); + + private native void subscribeGroupKeyMapAttribute( + long chipClusterPtr, + GroupKeyMapAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readGroupTableAttribute( + long chipClusterPtr, GroupTableAttributeCallback callback); + + private native void subscribeGroupTableAttribute( + long chipClusterPtr, + GroupTableAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readMaxGroupsPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxGroupsPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxGroupKeysPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxGroupKeysPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GroupsCluster extends BaseChipCluster { @@ -6166,89 +6845,107 @@ public GroupsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addGroup(AddGroupResponseCallback callback - , Integer groupId, String groupName) { + public void addGroup(AddGroupResponseCallback callback, Integer groupId, String groupName) { addGroup(chipClusterPtr, callback, groupId, groupName, null); } - public void addGroup(AddGroupResponseCallback callback - , Integer groupId, String groupName - , int timedInvokeTimeoutMs) { + public void addGroup( + AddGroupResponseCallback callback, + Integer groupId, + String groupName, + int timedInvokeTimeoutMs) { addGroup(chipClusterPtr, callback, groupId, groupName, timedInvokeTimeoutMs); } - public void addGroupIfIdentifying(DefaultClusterCallback callback - , Integer groupId, String groupName) { + public void addGroupIfIdentifying( + DefaultClusterCallback callback, Integer groupId, String groupName) { addGroupIfIdentifying(chipClusterPtr, callback, groupId, groupName, null); } - public void addGroupIfIdentifying(DefaultClusterCallback callback - , Integer groupId, String groupName - , int timedInvokeTimeoutMs) { + public void addGroupIfIdentifying( + DefaultClusterCallback callback, + Integer groupId, + String groupName, + int timedInvokeTimeoutMs) { addGroupIfIdentifying(chipClusterPtr, callback, groupId, groupName, timedInvokeTimeoutMs); } - public void getGroupMembership(GetGroupMembershipResponseCallback callback - , ArrayList groupList) { + public void getGroupMembership( + GetGroupMembershipResponseCallback callback, ArrayList groupList) { getGroupMembership(chipClusterPtr, callback, groupList, null); } - public void getGroupMembership(GetGroupMembershipResponseCallback callback - , ArrayList groupList - , int timedInvokeTimeoutMs) { + public void getGroupMembership( + GetGroupMembershipResponseCallback callback, + ArrayList groupList, + int timedInvokeTimeoutMs) { getGroupMembership(chipClusterPtr, callback, groupList, timedInvokeTimeoutMs); } - public void removeAllGroups(DefaultClusterCallback callback - ) { + public void removeAllGroups(DefaultClusterCallback callback) { removeAllGroups(chipClusterPtr, callback, null); } - public void removeAllGroups(DefaultClusterCallback callback + public void removeAllGroups(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { removeAllGroups(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void removeGroup(RemoveGroupResponseCallback callback - , Integer groupId) { + public void removeGroup(RemoveGroupResponseCallback callback, Integer groupId) { removeGroup(chipClusterPtr, callback, groupId, null); } - public void removeGroup(RemoveGroupResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void removeGroup( + RemoveGroupResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { removeGroup(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void viewGroup(ViewGroupResponseCallback callback - , Integer groupId) { + public void viewGroup(ViewGroupResponseCallback callback, Integer groupId) { viewGroup(chipClusterPtr, callback, groupId, null); } - public void viewGroup(ViewGroupResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void viewGroup( + ViewGroupResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { viewGroup(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - private native void addGroup(long chipClusterPtr, AddGroupResponseCallback Callback - , Integer groupId, String groupName - , @Nullable Integer timedInvokeTimeoutMs); - private native void addGroupIfIdentifying(long chipClusterPtr, DefaultClusterCallback Callback - , Integer groupId, String groupName - , @Nullable Integer timedInvokeTimeoutMs); - private native void getGroupMembership(long chipClusterPtr, GetGroupMembershipResponseCallback Callback - , ArrayList groupList - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeAllGroups(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeGroup(long chipClusterPtr, RemoveGroupResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); - private native void viewGroup(long chipClusterPtr, ViewGroupResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addGroup( + long chipClusterPtr, + AddGroupResponseCallback Callback, + Integer groupId, + String groupName, + @Nullable Integer timedInvokeTimeoutMs); + + private native void addGroupIfIdentifying( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer groupId, + String groupName, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getGroupMembership( + long chipClusterPtr, + GetGroupMembershipResponseCallback Callback, + ArrayList groupList, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeAllGroups( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeGroup( + long chipClusterPtr, + RemoveGroupResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void viewGroup( + long chipClusterPtr, + ViewGroupResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + public interface AddGroupResponseCallback { void onSuccess(Integer status, Integer groupId); @@ -6273,69 +6970,61 @@ public interface ViewGroupResponseCallback { void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readNameSupportAttribute( - IntegerAttributeCallback callback - ) { + public void readNameSupportAttribute(IntegerAttributeCallback callback) { readNameSupportAttribute(chipClusterPtr, callback); } + public void subscribeNameSupportAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class IdentifyCluster extends BaseChipCluster { @@ -6348,144 +7037,147 @@ public IdentifyCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void identify(DefaultClusterCallback callback - , Integer identifyTime) { + public void identify(DefaultClusterCallback callback, Integer identifyTime) { identify(chipClusterPtr, callback, identifyTime, null); } - public void identify(DefaultClusterCallback callback - , Integer identifyTime - , int timedInvokeTimeoutMs) { + public void identify( + DefaultClusterCallback callback, Integer identifyTime, int timedInvokeTimeoutMs) { identify(chipClusterPtr, callback, identifyTime, timedInvokeTimeoutMs); } - public void identifyQuery(IdentifyQueryResponseCallback callback - ) { + public void identifyQuery(IdentifyQueryResponseCallback callback) { identifyQuery(chipClusterPtr, callback, null); } - public void identifyQuery(IdentifyQueryResponseCallback callback + public void identifyQuery(IdentifyQueryResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { identifyQuery(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void triggerEffect(DefaultClusterCallback callback - , Integer effectIdentifier, Integer effectVariant) { + public void triggerEffect( + DefaultClusterCallback callback, Integer effectIdentifier, Integer effectVariant) { triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, null); } - public void triggerEffect(DefaultClusterCallback callback - , Integer effectIdentifier, Integer effectVariant - , int timedInvokeTimeoutMs) { - triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); + public void triggerEffect( + DefaultClusterCallback callback, + Integer effectIdentifier, + Integer effectVariant, + int timedInvokeTimeoutMs) { + triggerEffect( + chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); } - private native void identify(long chipClusterPtr, DefaultClusterCallback Callback - , Integer identifyTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void identifyQuery(long chipClusterPtr, IdentifyQueryResponseCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void triggerEffect(long chipClusterPtr, DefaultClusterCallback Callback - , Integer effectIdentifier, Integer effectVariant - , @Nullable Integer timedInvokeTimeoutMs); + private native void identify( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer identifyTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void identifyQuery( + long chipClusterPtr, + IdentifyQueryResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void triggerEffect( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer effectIdentifier, + Integer effectVariant, + @Nullable Integer timedInvokeTimeoutMs); + public interface IdentifyQueryResponseCallback { void onSuccess(Integer timeout); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readIdentifyTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readIdentifyTimeAttribute(IntegerAttributeCallback callback) { readIdentifyTimeAttribute(chipClusterPtr, callback); } + public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value) { writeIdentifyTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeIdentifyTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeIdentifyTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeIdentifyTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeIdentifyTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readIdentifyTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readIdentifyTypeAttribute(IntegerAttributeCallback callback) { readIdentifyTypeAttribute(chipClusterPtr, callback); } + public void subscribeIdentifyTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeIdentifyTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readIdentifyTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeIdentifyTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeIdentifyTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readIdentifyTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeIdentifyTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readIdentifyTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeIdentifyTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeIdentifyTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readIdentifyTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeIdentifyTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class IlluminanceMeasurementCluster extends BaseChipCluster { @@ -6498,164 +7190,165 @@ public IlluminanceMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface MeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface MinMeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface MaxMeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface LightSensorTypeAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute( - MeasuredValueAttributeCallback callback - ) { + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface LightSensorTypeAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(MeasuredValueAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - MeasuredValueAttributeCallback callback - , - int minInterval, int maxInterval) { + MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - MinMeasuredValueAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(MinMeasuredValueAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - MinMeasuredValueAttributeCallback callback - , - int minInterval, int maxInterval) { + MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - MaxMeasuredValueAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(MaxMeasuredValueAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - MaxMeasuredValueAttributeCallback callback - , - int minInterval, int maxInterval) { + MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { + public void readToleranceAttribute(IntegerAttributeCallback callback) { readToleranceAttribute(chipClusterPtr, callback); } + public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLightSensorTypeAttribute( - LightSensorTypeAttributeCallback callback - ) { + public void readLightSensorTypeAttribute(LightSensorTypeAttributeCallback callback) { readLightSensorTypeAttribute(chipClusterPtr, callback); } + public void subscribeLightSensorTypeAttribute( - LightSensorTypeAttributeCallback callback - , - int minInterval, int maxInterval) { + LightSensorTypeAttributeCallback callback, int minInterval, int maxInterval) { subscribeLightSensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - MeasuredValueAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - MeasuredValueAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - MinMeasuredValueAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - MinMeasuredValueAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - MaxMeasuredValueAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - MaxMeasuredValueAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLightSensorTypeAttribute(long chipClusterPtr, - LightSensorTypeAttributeCallback callback - ); - private native void subscribeLightSensorTypeAttribute(long chipClusterPtr, - LightSensorTypeAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, MeasuredValueAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, + MeasuredValueAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, MinMeasuredValueAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, + MinMeasuredValueAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, MaxMeasuredValueAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLightSensorTypeAttribute( + long chipClusterPtr, LightSensorTypeAttributeCallback callback); + + private native void subscribeLightSensorTypeAttribute( + long chipClusterPtr, + LightSensorTypeAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class KeypadInputCluster extends BaseChipCluster { @@ -6668,69 +7361,67 @@ public KeypadInputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void sendKeyRequest(SendKeyResponseCallback callback - , Integer keyCode) { + public void sendKeyRequest(SendKeyResponseCallback callback, Integer keyCode) { sendKeyRequest(chipClusterPtr, callback, keyCode, null); } - public void sendKeyRequest(SendKeyResponseCallback callback - , Integer keyCode - , int timedInvokeTimeoutMs) { + public void sendKeyRequest( + SendKeyResponseCallback callback, Integer keyCode, int timedInvokeTimeoutMs) { sendKeyRequest(chipClusterPtr, callback, keyCode, timedInvokeTimeoutMs); } - private native void sendKeyRequest(long chipClusterPtr, SendKeyResponseCallback Callback - , Integer keyCode - , @Nullable Integer timedInvokeTimeoutMs); + + private native void sendKeyRequest( + long chipClusterPtr, + SendKeyResponseCallback Callback, + Integer keyCode, + @Nullable Integer timedInvokeTimeoutMs); + public interface SendKeyResponseCallback { void onSuccess(Integer status); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 LevelControlCluster extends BaseChipCluster { @@ -6743,617 +7434,726 @@ public LevelControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void move(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride) { + public void move( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionMask, + Integer optionOverride) { move(chipClusterPtr, callback, moveMode, rate, optionMask, optionOverride, null); } - public void move(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - move(chipClusterPtr, callback, moveMode, rate, optionMask, optionOverride, timedInvokeTimeoutMs); + public void move( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + move( + chipClusterPtr, + callback, + moveMode, + rate, + optionMask, + optionOverride, + timedInvokeTimeoutMs); + } + + public void moveToLevel( + DefaultClusterCallback callback, + Integer level, + Integer transitionTime, + Integer optionMask, + Integer optionOverride) { + moveToLevel( + chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, null); + } + + public void moveToLevel( + DefaultClusterCallback callback, + Integer level, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + moveToLevel( + chipClusterPtr, + callback, + level, + transitionTime, + optionMask, + optionOverride, + timedInvokeTimeoutMs); + } + + public void moveToLevelWithOnOff( + DefaultClusterCallback callback, Integer level, Integer transitionTime) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, null); + } + + public void moveToLevelWithOnOff( + DefaultClusterCallback callback, + Integer level, + Integer transitionTime, + int timedInvokeTimeoutMs) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, timedInvokeTimeoutMs); } - public void moveToLevel(DefaultClusterCallback callback - , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride) { - moveToLevel(chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, null); + public void moveWithOnOff(DefaultClusterCallback callback, Integer moveMode, Integer rate) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, null); } - public void moveToLevel(DefaultClusterCallback callback - , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - moveToLevel(chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, timedInvokeTimeoutMs); + public void moveWithOnOff( + DefaultClusterCallback callback, Integer moveMode, Integer rate, int timedInvokeTimeoutMs) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, timedInvokeTimeoutMs); } - public void moveToLevelWithOnOff(DefaultClusterCallback callback - , Integer level, Integer transitionTime) { - moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, null); + public void step( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionMask, + Integer optionOverride) { + step( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionMask, + optionOverride, + null); + } + + public void step( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + step( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionMask, + optionOverride, + timedInvokeTimeoutMs); + } + + public void stepWithOnOff( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime) { + stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, null); } - public void moveToLevelWithOnOff(DefaultClusterCallback callback - , Integer level, Integer transitionTime - , int timedInvokeTimeoutMs) { - moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, timedInvokeTimeoutMs); + public void stepWithOnOff( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + int timedInvokeTimeoutMs) { + stepWithOnOff( + chipClusterPtr, callback, stepMode, stepSize, transitionTime, timedInvokeTimeoutMs); } - public void moveWithOnOff(DefaultClusterCallback callback - , Integer moveMode, Integer rate) { - moveWithOnOff(chipClusterPtr, callback, moveMode, rate, null); + public void stop(DefaultClusterCallback callback, Integer optionMask, Integer optionOverride) { + stop(chipClusterPtr, callback, optionMask, optionOverride, null); } - public void moveWithOnOff(DefaultClusterCallback callback - , Integer moveMode, Integer rate - , int timedInvokeTimeoutMs) { - moveWithOnOff(chipClusterPtr, callback, moveMode, rate, timedInvokeTimeoutMs); + public void stop( + DefaultClusterCallback callback, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + stop(chipClusterPtr, callback, optionMask, optionOverride, timedInvokeTimeoutMs); } - public void step(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride) { - step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionMask, optionOverride, null); + public void stopWithOnOff(DefaultClusterCallback callback) { + stopWithOnOff(chipClusterPtr, callback, null); } - public void step(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionMask, optionOverride, timedInvokeTimeoutMs); + public void stopWithOnOff(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void stepWithOnOff(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime) { - stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, null); + private native void move( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToLevel( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer level, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToLevelWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer level, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + @Nullable Integer timedInvokeTimeoutMs); + + private native void step( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stop( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface OnLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stepWithOnOff(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime - , int timedInvokeTimeoutMs) { - stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, timedInvokeTimeoutMs); + public interface OnTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stop(DefaultClusterCallback callback - , Integer optionMask, Integer optionOverride) { - stop(chipClusterPtr, callback, optionMask, optionOverride, null); + public interface OffTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stop(DefaultClusterCallback callback - , Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - stop(chipClusterPtr, callback, optionMask, optionOverride, timedInvokeTimeoutMs); + public interface DefaultMoveRateAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stopWithOnOff(DefaultClusterCallback callback - ) { - stopWithOnOff(chipClusterPtr, callback, null); + public interface StartUpCurrentLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stopWithOnOff(DefaultClusterCallback callback + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - , int timedInvokeTimeoutMs) { - stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void move(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToLevel(long chipClusterPtr, DefaultClusterCallback Callback - , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToLevelWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer level, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate - , @Nullable Integer timedInvokeTimeoutMs); - private native void step(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void stop(long chipClusterPtr, DefaultClusterCallback Callback - , Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - - public interface OnLevelAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface OnTransitionTimeAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface OffTransitionTimeAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface DefaultMoveRateAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface StartUpCurrentLevelAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readCurrentLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentLevelAttribute(IntegerAttributeCallback callback) { readCurrentLevelAttribute(chipClusterPtr, callback); } + public void subscribeCurrentLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRemainingTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readRemainingTimeAttribute(IntegerAttributeCallback callback) { readRemainingTimeAttribute(chipClusterPtr, callback); } + public void subscribeRemainingTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readMinLevelAttribute(IntegerAttributeCallback callback) { readMinLevelAttribute(chipClusterPtr, callback); } + public void subscribeMinLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxLevelAttribute(IntegerAttributeCallback callback) { readMaxLevelAttribute(chipClusterPtr, callback); } + public void subscribeMaxLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentFrequencyAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentFrequencyAttribute(IntegerAttributeCallback callback) { readCurrentFrequencyAttribute(chipClusterPtr, callback); } + public void subscribeCurrentFrequencyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinFrequencyAttribute( - IntegerAttributeCallback callback - ) { + public void readMinFrequencyAttribute(IntegerAttributeCallback callback) { readMinFrequencyAttribute(chipClusterPtr, callback); } + public void subscribeMinFrequencyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxFrequencyAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxFrequencyAttribute(IntegerAttributeCallback callback) { readMaxFrequencyAttribute(chipClusterPtr, callback); } + public void subscribeMaxFrequencyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOptionsAttribute( - IntegerAttributeCallback callback - ) { + public void readOptionsAttribute(IntegerAttributeCallback callback) { readOptionsAttribute(chipClusterPtr, callback); } + public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value) { writeOptionsAttribute(chipClusterPtr, callback, value, null); } - public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOptionsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOptionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnOffTransitionTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readOnOffTransitionTimeAttribute(IntegerAttributeCallback callback) { readOnOffTransitionTimeAttribute(chipClusterPtr, callback); } + public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnOffTransitionTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnOffTransitionTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnLevelAttribute( - OnLevelAttributeCallback callback - ) { + public void readOnLevelAttribute(OnLevelAttributeCallback callback) { readOnLevelAttribute(chipClusterPtr, callback); } + public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value) { writeOnLevelAttribute(chipClusterPtr, callback, value, null); } - public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnLevelAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnLevelAttribute( - OnLevelAttributeCallback callback - , - int minInterval, int maxInterval) { + OnLevelAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnTransitionTimeAttribute( - OnTransitionTimeAttributeCallback callback - ) { + public void readOnTransitionTimeAttribute(OnTransitionTimeAttributeCallback callback) { readOnTransitionTimeAttribute(chipClusterPtr, callback); } + public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnTransitionTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnTransitionTimeAttribute( - OnTransitionTimeAttributeCallback callback - , - int minInterval, int maxInterval) { + OnTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOffTransitionTimeAttribute( - OffTransitionTimeAttributeCallback callback - ) { + public void readOffTransitionTimeAttribute(OffTransitionTimeAttributeCallback callback) { readOffTransitionTimeAttribute(chipClusterPtr, callback); } + public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOffTransitionTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOffTransitionTimeAttribute( - OffTransitionTimeAttributeCallback callback - , - int minInterval, int maxInterval) { + OffTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) { subscribeOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDefaultMoveRateAttribute( - DefaultMoveRateAttributeCallback callback - ) { + public void readDefaultMoveRateAttribute(DefaultMoveRateAttributeCallback callback) { readDefaultMoveRateAttribute(chipClusterPtr, callback); } + public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value) { writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, null); } - public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeDefaultMoveRateAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeDefaultMoveRateAttribute( - DefaultMoveRateAttributeCallback callback - , - int minInterval, int maxInterval) { + DefaultMoveRateAttributeCallback callback, int minInterval, int maxInterval) { subscribeDefaultMoveRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpCurrentLevelAttribute( - StartUpCurrentLevelAttributeCallback callback - ) { + public void readStartUpCurrentLevelAttribute(StartUpCurrentLevelAttributeCallback callback) { readStartUpCurrentLevelAttribute(chipClusterPtr, callback); } + public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeStartUpCurrentLevelAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeStartUpCurrentLevelAttribute( - StartUpCurrentLevelAttributeCallback callback - , - int minInterval, int maxInterval) { + StartUpCurrentLevelAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartUpCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOnOffTransitionTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOnOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnOffTransitionTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOnLevelAttribute(long chipClusterPtr, - OnLevelAttributeCallback callback - ); - - private native void writeOnLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnLevelAttribute(long chipClusterPtr, - OnLevelAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOnTransitionTimeAttribute(long chipClusterPtr, - OnTransitionTimeAttributeCallback callback - ); - - private native void writeOnTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnTransitionTimeAttribute(long chipClusterPtr, - OnTransitionTimeAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOffTransitionTimeAttribute(long chipClusterPtr, - OffTransitionTimeAttributeCallback callback - ); - - private native void writeOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOffTransitionTimeAttribute(long chipClusterPtr, - OffTransitionTimeAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readDefaultMoveRateAttribute(long chipClusterPtr, - DefaultMoveRateAttributeCallback callback - ); - - private native void writeDefaultMoveRateAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeDefaultMoveRateAttribute(long chipClusterPtr, - DefaultMoveRateAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readStartUpCurrentLevelAttribute(long chipClusterPtr, - StartUpCurrentLevelAttributeCallback callback - ); - - private native void writeStartUpCurrentLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeStartUpCurrentLevelAttribute(long chipClusterPtr, - StartUpCurrentLevelAttributeCallback 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); - } + private native void readCurrentLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public static class LocalizationConfigurationCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 43L; + private native void subscribeCurrentLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public LocalizationConfigurationCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void readRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - @Override - public native long initWithDevice(long devicePtr, int endpointId); + private native void subscribeRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public interface SupportedLocalesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void readMinLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readActiveLocaleAttribute( - CharStringAttributeCallback callback - ) { - readActiveLocaleAttribute(chipClusterPtr, callback); - } - public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value) { - writeActiveLocaleAttribute(chipClusterPtr, callback, value, null); + private native void subscribeMinLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOptionsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnOffTransitionTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOnOffTransitionTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnOffTransitionTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnLevelAttribute( + long chipClusterPtr, OnLevelAttributeCallback callback); + + private native void writeOnLevelAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnLevelAttribute( + long chipClusterPtr, OnLevelAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnTransitionTimeAttribute( + long chipClusterPtr, OnTransitionTimeAttributeCallback callback); + + private native void writeOnTransitionTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnTransitionTimeAttribute( + long chipClusterPtr, + OnTransitionTimeAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOffTransitionTimeAttribute( + long chipClusterPtr, OffTransitionTimeAttributeCallback callback); + + private native void writeOffTransitionTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOffTransitionTimeAttribute( + long chipClusterPtr, + OffTransitionTimeAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readDefaultMoveRateAttribute( + long chipClusterPtr, DefaultMoveRateAttributeCallback callback); + + private native void writeDefaultMoveRateAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeDefaultMoveRateAttribute( + long chipClusterPtr, + DefaultMoveRateAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readStartUpCurrentLevelAttribute( + long chipClusterPtr, StartUpCurrentLevelAttributeCallback callback); + + private native void writeStartUpCurrentLevelAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeStartUpCurrentLevelAttribute( + long chipClusterPtr, + StartUpCurrentLevelAttributeCallback 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 LocalizationConfigurationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 43L; + + public LocalizationConfigurationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface SupportedLocalesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void readActiveLocaleAttribute(CharStringAttributeCallback callback) { + readActiveLocaleAttribute(chipClusterPtr, callback); + } + + public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value) { + writeActiveLocaleAttribute(chipClusterPtr, callback, value, null); + } + + public void writeActiveLocaleAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeActiveLocaleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeActiveLocaleAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveLocaleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedLocalesAttribute( - SupportedLocalesAttributeCallback callback - ) { + public void readSupportedLocalesAttribute(SupportedLocalesAttributeCallback callback) { readSupportedLocalesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedLocalesAttribute( - SupportedLocalesAttributeCallback callback - , - int minInterval, int maxInterval) { + SupportedLocalesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedLocalesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readActiveLocaleAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeActiveLocaleAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeActiveLocaleAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedLocalesAttribute(long chipClusterPtr, - SupportedLocalesAttributeCallback callback - ); - private native void subscribeSupportedLocalesAttribute(long chipClusterPtr, - SupportedLocalesAttributeCallback 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); + private native void readActiveLocaleAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeActiveLocaleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeActiveLocaleAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSupportedLocalesAttribute( + long chipClusterPtr, SupportedLocalesAttributeCallback callback); + + private native void subscribeSupportedLocalesAttribute( + long chipClusterPtr, + SupportedLocalesAttributeCallback 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 LowPowerCluster extends BaseChipCluster { @@ -7366,63 +8166,60 @@ public LowPowerCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void sleep(DefaultClusterCallback callback - ) { + public void sleep(DefaultClusterCallback callback) { sleep(chipClusterPtr, callback, null); } - public void sleep(DefaultClusterCallback callback + public void sleep(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { sleep(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void sleep(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void sleep( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - private native void readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class MediaInputCluster extends BaseChipCluster { @@ -7435,148 +8232,146 @@ public MediaInputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void hideInputStatusRequest(DefaultClusterCallback callback - ) { + public void hideInputStatusRequest(DefaultClusterCallback callback) { hideInputStatusRequest(chipClusterPtr, callback, null); } - public void hideInputStatusRequest(DefaultClusterCallback callback + public void hideInputStatusRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { hideInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void renameInputRequest(DefaultClusterCallback callback - , Integer index, String name) { + public void renameInputRequest(DefaultClusterCallback callback, Integer index, String name) { renameInputRequest(chipClusterPtr, callback, index, name, null); } - public void renameInputRequest(DefaultClusterCallback callback - , Integer index, String name - , int timedInvokeTimeoutMs) { + public void renameInputRequest( + DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) { renameInputRequest(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); } - public void selectInputRequest(DefaultClusterCallback callback - , Integer index) { + public void selectInputRequest(DefaultClusterCallback callback, Integer index) { selectInputRequest(chipClusterPtr, callback, index, null); } - public void selectInputRequest(DefaultClusterCallback callback - , Integer index - , int timedInvokeTimeoutMs) { + public void selectInputRequest( + DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) { selectInputRequest(chipClusterPtr, callback, index, timedInvokeTimeoutMs); } - public void showInputStatusRequest(DefaultClusterCallback callback - ) { + public void showInputStatusRequest(DefaultClusterCallback callback) { showInputStatusRequest(chipClusterPtr, callback, null); } - public void showInputStatusRequest(DefaultClusterCallback callback + public void showInputStatusRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { showInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void hideInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void renameInputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index, String name - , @Nullable Integer timedInvokeTimeoutMs); - private native void selectInputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index - , @Nullable Integer timedInvokeTimeoutMs); - private native void showInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback + private native void hideInputStatusRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); + private native void renameInputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + String name, + @Nullable Integer timedInvokeTimeoutMs); - public interface MediaInputListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void selectInputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + @Nullable Integer timedInvokeTimeoutMs); + + private native void showInputStatusRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface MediaInputListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readMediaInputListAttribute( - MediaInputListAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMediaInputListAttribute(MediaInputListAttributeCallback callback) { readMediaInputListAttribute(chipClusterPtr, callback); } + public void subscribeMediaInputListAttribute( - MediaInputListAttributeCallback callback - , - int minInterval, int maxInterval) { + MediaInputListAttributeCallback callback, int minInterval, int maxInterval) { subscribeMediaInputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentMediaInputAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentMediaInputAttribute(IntegerAttributeCallback callback) { readCurrentMediaInputAttribute(chipClusterPtr, callback); } + public void subscribeCurrentMediaInputAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentMediaInputAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMediaInputListAttribute(long chipClusterPtr, - MediaInputListAttributeCallback callback - ); - private native void subscribeMediaInputListAttribute(long chipClusterPtr, - MediaInputListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentMediaInputAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentMediaInputAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMediaInputListAttribute( + long chipClusterPtr, MediaInputListAttributeCallback callback); + + private native void subscribeMediaInputListAttribute( + long chipClusterPtr, + MediaInputListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentMediaInputAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentMediaInputAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class MediaPlaybackCluster extends BaseChipCluster { @@ -7589,323 +8384,304 @@ public MediaPlaybackCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void fastForwardRequest(PlaybackResponseCallback callback - ) { + public void fastForwardRequest(PlaybackResponseCallback callback) { fastForwardRequest(chipClusterPtr, callback, null); } - public void fastForwardRequest(PlaybackResponseCallback callback + public void fastForwardRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { fastForwardRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void nextRequest(PlaybackResponseCallback callback - ) { + public void nextRequest(PlaybackResponseCallback callback) { nextRequest(chipClusterPtr, callback, null); } - public void nextRequest(PlaybackResponseCallback callback + public void nextRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { nextRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void pauseRequest(PlaybackResponseCallback callback - ) { + public void pauseRequest(PlaybackResponseCallback callback) { pauseRequest(chipClusterPtr, callback, null); } - public void pauseRequest(PlaybackResponseCallback callback + public void pauseRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { pauseRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void playRequest(PlaybackResponseCallback callback - ) { + public void playRequest(PlaybackResponseCallback callback) { playRequest(chipClusterPtr, callback, null); } - public void playRequest(PlaybackResponseCallback callback + public void playRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { playRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void previousRequest(PlaybackResponseCallback callback - ) { + public void previousRequest(PlaybackResponseCallback callback) { previousRequest(chipClusterPtr, callback, null); } - public void previousRequest(PlaybackResponseCallback callback + public void previousRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { previousRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void rewindRequest(PlaybackResponseCallback callback - ) { + public void rewindRequest(PlaybackResponseCallback callback) { rewindRequest(chipClusterPtr, callback, null); } - public void rewindRequest(PlaybackResponseCallback callback + public void rewindRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { rewindRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void seekRequest(PlaybackResponseCallback callback - , Long position) { + public void seekRequest(PlaybackResponseCallback callback, Long position) { seekRequest(chipClusterPtr, callback, position, null); } - public void seekRequest(PlaybackResponseCallback callback - , Long position - , int timedInvokeTimeoutMs) { + public void seekRequest( + PlaybackResponseCallback callback, Long position, int timedInvokeTimeoutMs) { seekRequest(chipClusterPtr, callback, position, timedInvokeTimeoutMs); } - public void skipBackwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds) { + public void skipBackwardRequest( + PlaybackResponseCallback callback, Long deltaPositionMilliseconds) { skipBackwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, null); } - public void skipBackwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds - , int timedInvokeTimeoutMs) { - skipBackwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); + public void skipBackwardRequest( + PlaybackResponseCallback callback, + Long deltaPositionMilliseconds, + int timedInvokeTimeoutMs) { + skipBackwardRequest( + chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); } - public void skipForwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds) { + public void skipForwardRequest( + PlaybackResponseCallback callback, Long deltaPositionMilliseconds) { skipForwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, null); } - public void skipForwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds - , int timedInvokeTimeoutMs) { + public void skipForwardRequest( + PlaybackResponseCallback callback, + Long deltaPositionMilliseconds, + int timedInvokeTimeoutMs) { skipForwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); } - public void startOverRequest(PlaybackResponseCallback callback - ) { + public void startOverRequest(PlaybackResponseCallback callback) { startOverRequest(chipClusterPtr, callback, null); } - public void startOverRequest(PlaybackResponseCallback callback + public void startOverRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { startOverRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void stopRequest(PlaybackResponseCallback callback - ) { + public void stopRequest(PlaybackResponseCallback callback) { stopRequest(chipClusterPtr, callback, null); } - public void stopRequest(PlaybackResponseCallback callback + public void stopRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { stopRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void fastForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void nextRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void pauseRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void playRequest(long chipClusterPtr, PlaybackResponseCallback Callback + private native void fastForwardRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void nextRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void pauseRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void playRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void previousRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void rewindRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void seekRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + Long position, + @Nullable Integer timedInvokeTimeoutMs); + + private native void skipBackwardRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + Long deltaPositionMilliseconds, + @Nullable Integer timedInvokeTimeoutMs); + + private native void skipForwardRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + Long deltaPositionMilliseconds, + @Nullable Integer timedInvokeTimeoutMs); + + private native void startOverRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void previousRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void rewindRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void seekRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , Long position - , @Nullable Integer timedInvokeTimeoutMs); - private native void skipBackwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , Long deltaPositionMilliseconds - , @Nullable Integer timedInvokeTimeoutMs); - private native void skipForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , Long deltaPositionMilliseconds - , @Nullable Integer timedInvokeTimeoutMs); - private native void startOverRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); public interface PlaybackResponseCallback { void onSuccess(Integer status); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readPlaybackStateAttribute( - IntegerAttributeCallback callback - ) { + public void readPlaybackStateAttribute(IntegerAttributeCallback callback) { readPlaybackStateAttribute(chipClusterPtr, callback); } + public void subscribePlaybackStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePlaybackStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartTimeAttribute( - LongAttributeCallback callback - ) { + public void readStartTimeAttribute(LongAttributeCallback callback) { readStartTimeAttribute(chipClusterPtr, callback); } + public void subscribeStartTimeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDurationAttribute( - LongAttributeCallback callback - ) { + public void readDurationAttribute(LongAttributeCallback callback) { readDurationAttribute(chipClusterPtr, callback); } + public void subscribeDurationAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPlaybackSpeedAttribute( - FloatAttributeCallback callback - ) { + public void readPlaybackSpeedAttribute(FloatAttributeCallback callback) { readPlaybackSpeedAttribute(chipClusterPtr, callback); } + public void subscribePlaybackSpeedAttribute( - FloatAttributeCallback callback -, - int minInterval, int maxInterval) { + FloatAttributeCallback callback, int minInterval, int maxInterval) { subscribePlaybackSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSeekRangeEndAttribute( - LongAttributeCallback callback - ) { + public void readSeekRangeEndAttribute(LongAttributeCallback callback) { readSeekRangeEndAttribute(chipClusterPtr, callback); } + public void subscribeSeekRangeEndAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeSeekRangeEndAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSeekRangeStartAttribute( - LongAttributeCallback callback - ) { + public void readSeekRangeStartAttribute(LongAttributeCallback callback) { readSeekRangeStartAttribute(chipClusterPtr, callback); } + public void subscribeSeekRangeStartAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeSeekRangeStartAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readPlaybackStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePlaybackStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeStartTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDurationAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeDurationAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPlaybackSpeedAttribute(long chipClusterPtr, - FloatAttributeCallback callback - ); - private native void subscribePlaybackSpeedAttribute(long chipClusterPtr, - FloatAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSeekRangeEndAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeSeekRangeEndAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSeekRangeStartAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeSeekRangeStartAttribute(long chipClusterPtr, - LongAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readPlaybackStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePlaybackStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartTimeAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeStartTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDurationAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeDurationAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPlaybackSpeedAttribute( + long chipClusterPtr, FloatAttributeCallback callback); + + private native void subscribePlaybackSpeedAttribute( + long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSeekRangeEndAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeSeekRangeEndAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSeekRangeStartAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeSeekRangeStartAttribute( + long chipClusterPtr, LongAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ModeSelectCluster extends BaseChipCluster { @@ -7918,172 +8694,164 @@ public ModeSelectCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void changeToMode(DefaultClusterCallback callback - , Integer newMode) { + public void changeToMode(DefaultClusterCallback callback, Integer newMode) { changeToMode(chipClusterPtr, callback, newMode, null); } - public void changeToMode(DefaultClusterCallback callback - , Integer newMode - , int timedInvokeTimeoutMs) { + public void changeToMode( + DefaultClusterCallback callback, Integer newMode, int timedInvokeTimeoutMs) { changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs); } - private native void changeToMode(long chipClusterPtr, DefaultClusterCallback Callback - , Integer newMode - , @Nullable Integer timedInvokeTimeoutMs); - public interface SupportedModesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void changeToMode( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer newMode, + @Nullable Integer timedInvokeTimeoutMs); + + public interface SupportedModesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readCurrentModeAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentModeAttribute(IntegerAttributeCallback callback) { readCurrentModeAttribute(chipClusterPtr, callback); } + public void subscribeCurrentModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedModesAttribute( - SupportedModesAttributeCallback callback - ) { + public void readSupportedModesAttribute(SupportedModesAttributeCallback callback) { readSupportedModesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedModesAttribute( - SupportedModesAttributeCallback callback - , - int minInterval, int maxInterval) { + SupportedModesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnModeAttribute( - IntegerAttributeCallback callback - ) { + public void readOnModeAttribute(IntegerAttributeCallback callback) { readOnModeAttribute(chipClusterPtr, callback); } + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) { writeOnModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpModeAttribute( - IntegerAttributeCallback callback - ) { + public void readStartUpModeAttribute(IntegerAttributeCallback callback) { readStartUpModeAttribute(chipClusterPtr, callback); } + public void subscribeStartUpModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDescriptionAttribute( - CharStringAttributeCallback callback - ) { + public void readDescriptionAttribute(CharStringAttributeCallback callback) { readDescriptionAttribute(chipClusterPtr, callback); } + public void subscribeDescriptionAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedModesAttribute(long chipClusterPtr, - SupportedModesAttributeCallback callback - ); - private native void subscribeSupportedModesAttribute(long chipClusterPtr, - SupportedModesAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOnModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartUpModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStartUpModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readCurrentModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSupportedModesAttribute( + long chipClusterPtr, SupportedModesAttributeCallback callback); + + private native void subscribeSupportedModesAttribute( + long chipClusterPtr, + SupportedModesAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOnModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOnModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartUpModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStartUpModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDescriptionAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeDescriptionAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class NetworkCommissioningCluster extends BaseChipCluster { @@ -8096,89 +8864,135 @@ public NetworkCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback - , byte[] operationalDataset, Long breadcrumb) { + public void addOrUpdateThreadNetwork( + NetworkConfigResponseCallback callback, byte[] operationalDataset, Long breadcrumb) { addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, null); } - public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback - , byte[] operationalDataset, Long breadcrumb - , int timedInvokeTimeoutMs) { - addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs); + public void addOrUpdateThreadNetwork( + NetworkConfigResponseCallback callback, + byte[] operationalDataset, + Long breadcrumb, + int timedInvokeTimeoutMs) { + addOrUpdateThreadNetwork( + chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs); } - public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback - , byte[] ssid, byte[] credentials, Long breadcrumb) { + public void addOrUpdateWiFiNetwork( + NetworkConfigResponseCallback callback, byte[] ssid, byte[] credentials, Long breadcrumb) { addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, null); } - public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback - , byte[] ssid, byte[] credentials, Long breadcrumb - , int timedInvokeTimeoutMs) { - addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs); + public void addOrUpdateWiFiNetwork( + NetworkConfigResponseCallback callback, + byte[] ssid, + byte[] credentials, + Long breadcrumb, + int timedInvokeTimeoutMs) { + addOrUpdateWiFiNetwork( + chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs); } - public void connectNetwork(ConnectNetworkResponseCallback callback - , byte[] networkID, Long breadcrumb) { + public void connectNetwork( + ConnectNetworkResponseCallback callback, byte[] networkID, Long breadcrumb) { connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); } - public void connectNetwork(ConnectNetworkResponseCallback callback - , byte[] networkID, Long breadcrumb - , int timedInvokeTimeoutMs) { + public void connectNetwork( + ConnectNetworkResponseCallback callback, + byte[] networkID, + Long breadcrumb, + int timedInvokeTimeoutMs) { connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); } - public void removeNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Long breadcrumb) { + public void removeNetwork( + NetworkConfigResponseCallback callback, byte[] networkID, Long breadcrumb) { removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); } - public void removeNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Long breadcrumb - , int timedInvokeTimeoutMs) { + public void removeNetwork( + NetworkConfigResponseCallback callback, + byte[] networkID, + Long breadcrumb, + int timedInvokeTimeoutMs) { removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); } - public void reorderNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Integer networkIndex, Long breadcrumb) { + public void reorderNetwork( + NetworkConfigResponseCallback callback, + byte[] networkID, + Integer networkIndex, + Long breadcrumb) { reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, null); } - public void reorderNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Integer networkIndex, Long breadcrumb - , int timedInvokeTimeoutMs) { - reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs); + public void reorderNetwork( + NetworkConfigResponseCallback callback, + byte[] networkID, + Integer networkIndex, + Long breadcrumb, + int timedInvokeTimeoutMs) { + reorderNetwork( + chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs); } - public void scanNetworks(ScanNetworksResponseCallback callback - , byte[] ssid, Long breadcrumb) { + public void scanNetworks(ScanNetworksResponseCallback callback, byte[] ssid, Long breadcrumb) { scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, null); } - public void scanNetworks(ScanNetworksResponseCallback callback - , byte[] ssid, Long breadcrumb - , int timedInvokeTimeoutMs) { + public void scanNetworks( + ScanNetworksResponseCallback callback, + byte[] ssid, + Long breadcrumb, + int timedInvokeTimeoutMs) { scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, timedInvokeTimeoutMs); } - private native void addOrUpdateThreadNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] operationalDataset, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void addOrUpdateWiFiNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] ssid, byte[] credentials, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void connectNetwork(long chipClusterPtr, ConnectNetworkResponseCallback Callback - , byte[] networkID, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] networkID, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void reorderNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] networkID, Integer networkIndex, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void scanNetworks(long chipClusterPtr, ScanNetworksResponseCallback Callback - , byte[] ssid, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addOrUpdateThreadNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] operationalDataset, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void addOrUpdateWiFiNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] ssid, + byte[] credentials, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void connectNetwork( + long chipClusterPtr, + ConnectNetworkResponseCallback Callback, + byte[] networkID, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] networkID, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void reorderNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] networkID, + Integer networkIndex, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void scanNetworks( + long chipClusterPtr, + ScanNetworksResponseCallback Callback, + byte[] ssid, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + public interface ConnectNetworkResponseCallback { void onSuccess(Integer networkingStatus, String debugText, Long errorValue); @@ -8192,216 +9006,192 @@ public interface NetworkConfigResponseCallback { } public interface ScanNetworksResponseCallback { - void onSuccess(Integer networkingStatus, String debugText, Optional> wiFiScanResults, Optional> threadScanResults); + void onSuccess( + Integer networkingStatus, + String debugText, + Optional> + wiFiScanResults, + Optional> + threadScanResults); void onError(Exception error); } + public interface NetworksAttributeCallback { + void onSuccess(List valueList); - public interface NetworksAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readMaxNetworksAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxNetworksAttribute(IntegerAttributeCallback callback) { readMaxNetworksAttribute(chipClusterPtr, callback); } + public void subscribeMaxNetworksAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNetworksAttribute( - NetworksAttributeCallback callback - ) { + public void readNetworksAttribute(NetworksAttributeCallback callback) { readNetworksAttribute(chipClusterPtr, callback); } + public void subscribeNetworksAttribute( - NetworksAttributeCallback callback - , - int minInterval, int maxInterval) { + NetworksAttributeCallback callback, int minInterval, int maxInterval) { subscribeNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readScanMaxTimeSecondsAttribute( - IntegerAttributeCallback callback - ) { + public void readScanMaxTimeSecondsAttribute(IntegerAttributeCallback callback) { readScanMaxTimeSecondsAttribute(chipClusterPtr, callback); } + public void subscribeScanMaxTimeSecondsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeScanMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readConnectMaxTimeSecondsAttribute( - IntegerAttributeCallback callback - ) { + public void readConnectMaxTimeSecondsAttribute(IntegerAttributeCallback callback) { readConnectMaxTimeSecondsAttribute(chipClusterPtr, callback); } + public void subscribeConnectMaxTimeSecondsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeConnectMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInterfaceEnabledAttribute( - BooleanAttributeCallback callback - ) { + public void readInterfaceEnabledAttribute(BooleanAttributeCallback callback) { readInterfaceEnabledAttribute(chipClusterPtr, callback); } + public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value) { writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, null); } - public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeInterfaceEnabledAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInterfaceEnabledAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeInterfaceEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastNetworkingStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readLastNetworkingStatusAttribute(IntegerAttributeCallback callback) { readLastNetworkingStatusAttribute(chipClusterPtr, callback); } + public void subscribeLastNetworkingStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLastNetworkingStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastNetworkIDAttribute( - OctetStringAttributeCallback callback - ) { + public void readLastNetworkIDAttribute(OctetStringAttributeCallback callback) { readLastNetworkIDAttribute(chipClusterPtr, callback); } + public void subscribeLastNetworkIDAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLastNetworkIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastConnectErrorValueAttribute( - LongAttributeCallback callback - ) { + public void readLastConnectErrorValueAttribute(LongAttributeCallback callback) { readLastConnectErrorValueAttribute(chipClusterPtr, callback); } + public void subscribeLastConnectErrorValueAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeLastConnectErrorValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMaxNetworksAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxNetworksAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNetworksAttribute(long chipClusterPtr, - NetworksAttributeCallback callback - ); - private native void subscribeNetworksAttribute(long chipClusterPtr, - NetworksAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readScanMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeScanMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readConnectMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeConnectMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInterfaceEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeInterfaceEnabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInterfaceEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLastNetworkingStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLastNetworkingStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLastNetworkIDAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeLastNetworkIDAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLastConnectErrorValueAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeLastConnectErrorValueAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readMaxNetworksAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxNetworksAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNetworksAttribute( + long chipClusterPtr, NetworksAttributeCallback callback); + + private native void subscribeNetworksAttribute( + long chipClusterPtr, NetworksAttributeCallback callback, int minInterval, int maxInterval); + + private native void readScanMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeScanMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readConnectMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeConnectMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInterfaceEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeInterfaceEnabledAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInterfaceEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLastNetworkingStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLastNetworkingStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLastNetworkIDAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeLastNetworkIDAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLastConnectErrorValueAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeLastConnectErrorValueAttribute( + long chipClusterPtr, LongAttributeCallback 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 OtaSoftwareUpdateProviderCluster extends BaseChipCluster { @@ -8414,47 +9204,109 @@ public OtaSoftwareUpdateProviderCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void applyUpdateRequest(ApplyUpdateResponseCallback callback - , byte[] updateToken, Long newVersion) { + public void applyUpdateRequest( + ApplyUpdateResponseCallback callback, byte[] updateToken, Long newVersion) { applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, null); } - public void applyUpdateRequest(ApplyUpdateResponseCallback callback - , byte[] updateToken, Long newVersion - , int timedInvokeTimeoutMs) { + public void applyUpdateRequest( + ApplyUpdateResponseCallback callback, + byte[] updateToken, + Long newVersion, + int timedInvokeTimeoutMs) { applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, timedInvokeTimeoutMs); } - public void notifyUpdateApplied(DefaultClusterCallback callback - , byte[] updateToken, Long softwareVersion) { + public void notifyUpdateApplied( + DefaultClusterCallback callback, byte[] updateToken, Long softwareVersion) { notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, null); } - public void notifyUpdateApplied(DefaultClusterCallback callback - , byte[] updateToken, Long softwareVersion - , int timedInvokeTimeoutMs) { - notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs); - } - - public void queryImage(QueryImageResponseCallback callback - , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider) { - queryImage(chipClusterPtr, callback, vendorId, productId, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, null); - } + public void notifyUpdateApplied( + DefaultClusterCallback callback, + byte[] updateToken, + Long softwareVersion, + int timedInvokeTimeoutMs) { + notifyUpdateApplied( + chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs); + } + + public void queryImage( + QueryImageResponseCallback callback, + Integer vendorId, + Integer productId, + Long softwareVersion, + ArrayList protocolsSupported, + Optional hardwareVersion, + Optional location, + Optional requestorCanConsent, + Optional metadataForProvider) { + queryImage( + chipClusterPtr, + callback, + vendorId, + productId, + softwareVersion, + protocolsSupported, + hardwareVersion, + location, + requestorCanConsent, + metadataForProvider, + null); + } + + public void queryImage( + QueryImageResponseCallback callback, + Integer vendorId, + Integer productId, + Long softwareVersion, + ArrayList protocolsSupported, + Optional hardwareVersion, + Optional location, + Optional requestorCanConsent, + Optional metadataForProvider, + int timedInvokeTimeoutMs) { + queryImage( + chipClusterPtr, + callback, + vendorId, + productId, + softwareVersion, + protocolsSupported, + hardwareVersion, + location, + requestorCanConsent, + metadataForProvider, + timedInvokeTimeoutMs); + } + + private native void applyUpdateRequest( + long chipClusterPtr, + ApplyUpdateResponseCallback Callback, + byte[] updateToken, + Long newVersion, + @Nullable Integer timedInvokeTimeoutMs); + + private native void notifyUpdateApplied( + long chipClusterPtr, + DefaultClusterCallback Callback, + byte[] updateToken, + Long softwareVersion, + @Nullable Integer timedInvokeTimeoutMs); + + private native void queryImage( + long chipClusterPtr, + QueryImageResponseCallback Callback, + Integer vendorId, + Integer productId, + Long softwareVersion, + ArrayList protocolsSupported, + Optional hardwareVersion, + Optional location, + Optional requestorCanConsent, + Optional metadataForProvider, + @Nullable Integer timedInvokeTimeoutMs); - public void queryImage(QueryImageResponseCallback callback - , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider - , int timedInvokeTimeoutMs) { - queryImage(chipClusterPtr, callback, vendorId, productId, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, timedInvokeTimeoutMs); - } - private native void applyUpdateRequest(long chipClusterPtr, ApplyUpdateResponseCallback Callback - , byte[] updateToken, Long newVersion - , @Nullable Integer timedInvokeTimeoutMs); - private native void notifyUpdateApplied(long chipClusterPtr, DefaultClusterCallback Callback - , byte[] updateToken, Long softwareVersion - , @Nullable Integer timedInvokeTimeoutMs); - private native void queryImage(long chipClusterPtr, QueryImageResponseCallback Callback - , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider - , @Nullable Integer timedInvokeTimeoutMs); public interface ApplyUpdateResponseCallback { void onSuccess(Integer action, Long delayedActionTime); @@ -8462,55 +9314,59 @@ public interface ApplyUpdateResponseCallback { } public interface QueryImageResponseCallback { - void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor); + void onSuccess( + Integer status, + Optional delayedActionTime, + Optional imageURI, + Optional softwareVersion, + Optional softwareVersionString, + Optional updateToken, + Optional userConsentNeeded, + Optional metadataForRequestor); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 OtaSoftwareUpdateRequestorCluster extends BaseChipCluster { @@ -8523,158 +9379,194 @@ public OtaSoftwareUpdateRequestorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void announceOtaProvider(DefaultClusterCallback callback - , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint) { - announceOtaProvider(chipClusterPtr, callback, providerNodeId, vendorId, announcementReason, metadataForNode, endpoint, null); + public void announceOtaProvider( + DefaultClusterCallback callback, + Long providerNodeId, + Integer vendorId, + Integer announcementReason, + Optional metadataForNode, + Integer endpoint) { + announceOtaProvider( + chipClusterPtr, + callback, + providerNodeId, + vendorId, + announcementReason, + metadataForNode, + endpoint, + null); } - public void announceOtaProvider(DefaultClusterCallback callback - , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint - , int timedInvokeTimeoutMs) { - announceOtaProvider(chipClusterPtr, callback, providerNodeId, vendorId, announcementReason, metadataForNode, endpoint, timedInvokeTimeoutMs); + public void announceOtaProvider( + DefaultClusterCallback callback, + Long providerNodeId, + Integer vendorId, + Integer announcementReason, + Optional metadataForNode, + Integer endpoint, + int timedInvokeTimeoutMs) { + announceOtaProvider( + chipClusterPtr, + callback, + providerNodeId, + vendorId, + announcementReason, + metadataForNode, + endpoint, + timedInvokeTimeoutMs); } - private native void announceOtaProvider(long chipClusterPtr, DefaultClusterCallback Callback - , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint - , @Nullable Integer timedInvokeTimeoutMs); - public interface DefaultOtaProvidersAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface UpdateStateProgressAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void announceOtaProvider( + long chipClusterPtr, + DefaultClusterCallback Callback, + Long providerNodeId, + Integer vendorId, + Integer announcementReason, + Optional metadataForNode, + Integer endpoint, + @Nullable Integer timedInvokeTimeoutMs); + + public interface DefaultOtaProvidersAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface UpdateStateProgressAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readDefaultOtaProvidersAttribute( - DefaultOtaProvidersAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readDefaultOtaProvidersAttribute(DefaultOtaProvidersAttributeCallback callback) { readDefaultOtaProvidersAttribute(chipClusterPtr, callback); } - public void writeDefaultOtaProvidersAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeDefaultOtaProvidersAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeDefaultOtaProvidersAttribute(chipClusterPtr, callback, value, null); } - public void writeDefaultOtaProvidersAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeDefaultOtaProvidersAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeDefaultOtaProvidersAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeDefaultOtaProvidersAttribute( - DefaultOtaProvidersAttributeCallback callback - , - int minInterval, int maxInterval) { + DefaultOtaProvidersAttributeCallback callback, int minInterval, int maxInterval) { subscribeDefaultOtaProvidersAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdatePossibleAttribute( - BooleanAttributeCallback callback - ) { + public void readUpdatePossibleAttribute(BooleanAttributeCallback callback) { readUpdatePossibleAttribute(chipClusterPtr, callback); } + public void subscribeUpdatePossibleAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpdatePossibleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdateStateAttribute( - IntegerAttributeCallback callback - ) { + public void readUpdateStateAttribute(IntegerAttributeCallback callback) { readUpdateStateAttribute(chipClusterPtr, callback); } + public void subscribeUpdateStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpdateStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdateStateProgressAttribute( - UpdateStateProgressAttributeCallback callback - ) { + public void readUpdateStateProgressAttribute(UpdateStateProgressAttributeCallback callback) { readUpdateStateProgressAttribute(chipClusterPtr, callback); } + public void subscribeUpdateStateProgressAttribute( - UpdateStateProgressAttributeCallback callback - , - int minInterval, int maxInterval) { + UpdateStateProgressAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpdateStateProgressAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readDefaultOtaProvidersAttribute(long chipClusterPtr, - DefaultOtaProvidersAttributeCallback callback - ); - - private native void writeDefaultOtaProvidersAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeDefaultOtaProvidersAttribute(long chipClusterPtr, - DefaultOtaProvidersAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readUpdatePossibleAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeUpdatePossibleAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUpdateStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeUpdateStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUpdateStateProgressAttribute(long chipClusterPtr, - UpdateStateProgressAttributeCallback callback - ); - private native void subscribeUpdateStateProgressAttribute(long chipClusterPtr, - UpdateStateProgressAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readDefaultOtaProvidersAttribute( + long chipClusterPtr, DefaultOtaProvidersAttributeCallback callback); + + private native void writeDefaultOtaProvidersAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeDefaultOtaProvidersAttribute( + long chipClusterPtr, + DefaultOtaProvidersAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readUpdatePossibleAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeUpdatePossibleAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUpdateStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeUpdateStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUpdateStateProgressAttribute( + long chipClusterPtr, UpdateStateProgressAttributeCallback callback); + + private native void subscribeUpdateStateProgressAttribute( + long chipClusterPtr, + UpdateStateProgressAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class OccupancySensingCluster extends BaseChipCluster { @@ -8687,106 +9579,92 @@ public OccupancySensingCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readOccupancyAttribute( - IntegerAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readOccupancyAttribute(IntegerAttributeCallback callback) { readOccupancyAttribute(chipClusterPtr, callback); } + public void subscribeOccupancyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupancyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupancySensorTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupancySensorTypeAttribute(IntegerAttributeCallback callback) { readOccupancySensorTypeAttribute(chipClusterPtr, callback); } + public void subscribeOccupancySensorTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupancySensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupancySensorTypeBitmapAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupancySensorTypeBitmapAttribute(IntegerAttributeCallback callback) { readOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback); } + public void subscribeOccupancySensorTypeBitmapAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeOccupancySensorTypeBitmapAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOccupancyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOccupancyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupancySensorTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOccupancySensorTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupancySensorTypeBitmapAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOccupancySensorTypeBitmapAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readOccupancyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOccupancyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOccupancySensorTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeBitmapAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOccupancySensorTypeBitmapAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class OnOffCluster extends BaseChipCluster { @@ -8799,274 +9677,281 @@ public OnOffCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void off(DefaultClusterCallback callback - ) { + public void off(DefaultClusterCallback callback) { off(chipClusterPtr, callback, null); } - public void off(DefaultClusterCallback callback + public void off(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { off(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void offWithEffect(DefaultClusterCallback callback - , Integer effectId, Integer effectVariant) { + public void offWithEffect( + DefaultClusterCallback callback, Integer effectId, Integer effectVariant) { offWithEffect(chipClusterPtr, callback, effectId, effectVariant, null); } - public void offWithEffect(DefaultClusterCallback callback - , Integer effectId, Integer effectVariant - , int timedInvokeTimeoutMs) { + public void offWithEffect( + DefaultClusterCallback callback, + Integer effectId, + Integer effectVariant, + int timedInvokeTimeoutMs) { offWithEffect(chipClusterPtr, callback, effectId, effectVariant, timedInvokeTimeoutMs); } - public void on(DefaultClusterCallback callback - ) { + public void on(DefaultClusterCallback callback) { on(chipClusterPtr, callback, null); } - public void on(DefaultClusterCallback callback + public void on(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { on(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void onWithRecallGlobalScene(DefaultClusterCallback callback - ) { + public void onWithRecallGlobalScene(DefaultClusterCallback callback) { onWithRecallGlobalScene(chipClusterPtr, callback, null); } - public void onWithRecallGlobalScene(DefaultClusterCallback callback + public void onWithRecallGlobalScene(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { onWithRecallGlobalScene(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void onWithTimedOff(DefaultClusterCallback callback - , Integer onOffControl, Integer onTime, Integer offWaitTime) { + public void onWithTimedOff( + DefaultClusterCallback callback, + Integer onOffControl, + Integer onTime, + Integer offWaitTime) { onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, null); } - public void onWithTimedOff(DefaultClusterCallback callback - , Integer onOffControl, Integer onTime, Integer offWaitTime - , int timedInvokeTimeoutMs) { - onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs); + public void onWithTimedOff( + DefaultClusterCallback callback, + Integer onOffControl, + Integer onTime, + Integer offWaitTime, + int timedInvokeTimeoutMs) { + onWithTimedOff( + chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs); } - public void toggle(DefaultClusterCallback callback - ) { + public void toggle(DefaultClusterCallback callback) { toggle(chipClusterPtr, callback, null); } - public void toggle(DefaultClusterCallback callback + public void toggle(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { toggle(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void off(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void offWithEffect(long chipClusterPtr, DefaultClusterCallback Callback - , Integer effectId, Integer effectVariant - , @Nullable Integer timedInvokeTimeoutMs); - private native void on(long chipClusterPtr, DefaultClusterCallback Callback + private native void off( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void onWithRecallGlobalScene(long chipClusterPtr, DefaultClusterCallback Callback + private native void offWithEffect( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer effectId, + Integer effectVariant, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void onWithTimedOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer onOffControl, Integer onTime, Integer offWaitTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void toggle(long chipClusterPtr, DefaultClusterCallback Callback + private native void on( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); + private native void onWithRecallGlobalScene( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void onWithTimedOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer onOffControl, + Integer onTime, + Integer offWaitTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void toggle( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readOnOffAttribute( - BooleanAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readOnOffAttribute(BooleanAttributeCallback callback) { readOnOffAttribute(chipClusterPtr, callback); } + public void subscribeOnOffAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGlobalSceneControlAttribute( - BooleanAttributeCallback callback - ) { + public void readGlobalSceneControlAttribute(BooleanAttributeCallback callback) { readGlobalSceneControlAttribute(chipClusterPtr, callback); } + public void subscribeGlobalSceneControlAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeGlobalSceneControlAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readOnTimeAttribute(IntegerAttributeCallback callback) { readOnTimeAttribute(chipClusterPtr, callback); } + public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOffWaitTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readOffWaitTimeAttribute(IntegerAttributeCallback callback) { readOffWaitTimeAttribute(chipClusterPtr, callback); } + public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOffWaitTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOffWaitTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOffWaitTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOffWaitTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOffWaitTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpOnOffAttribute( - IntegerAttributeCallback callback - ) { + public void readStartUpOnOffAttribute(IntegerAttributeCallback callback) { readStartUpOnOffAttribute(chipClusterPtr, callback); } + public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpOnOffAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeStartUpOnOffAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeStartUpOnOffAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeStartUpOnOffAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartUpOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOnOffAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeOnOffAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readGlobalSceneControlAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeGlobalSceneControlAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOnTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOnTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOffWaitTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOffWaitTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOffWaitTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartUpOnOffAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeStartUpOnOffAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeStartUpOnOffAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readOnOffAttribute(long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeOnOffAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readGlobalSceneControlAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeGlobalSceneControlAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnTimeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOnTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOffWaitTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOffWaitTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOffWaitTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartUpOnOffAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeStartUpOnOffAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeStartUpOnOffAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 OnOffSwitchConfigurationCluster extends BaseChipCluster { @@ -9079,96 +9964,91 @@ public OnOffSwitchConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readSwitchTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readSwitchTypeAttribute(IntegerAttributeCallback callback) { readSwitchTypeAttribute(chipClusterPtr, callback); } + public void subscribeSwitchTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSwitchTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSwitchActionsAttribute( - IntegerAttributeCallback callback - ) { + public void readSwitchActionsAttribute(IntegerAttributeCallback callback) { readSwitchActionsAttribute(chipClusterPtr, callback); } + public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value) { writeSwitchActionsAttribute(chipClusterPtr, callback, value, null); } - public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSwitchActionsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSwitchActionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeSwitchActionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSwitchActionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSwitchTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSwitchTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSwitchActionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeSwitchActionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSwitchActionsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readSwitchTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSwitchTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSwitchActionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeSwitchActionsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSwitchActionsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class OperationalCredentialsCluster extends BaseChipCluster { @@ -9181,131 +10061,183 @@ public OperationalCredentialsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId) { - addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminNode, adminVendorId, null); - } - - public void addNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId - , int timedInvokeTimeoutMs) { - addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminNode, adminVendorId, timedInvokeTimeoutMs); - } - - public void addTrustedRootCertificate(DefaultClusterCallback callback - , byte[] rootCertificate) { + public void addNOC( + NOCResponseCallback callback, + byte[] NOCValue, + Optional ICACValue, + byte[] IPKValue, + Long caseAdminNode, + Integer adminVendorId) { + addNOC( + chipClusterPtr, + callback, + NOCValue, + ICACValue, + IPKValue, + caseAdminNode, + adminVendorId, + null); + } + + public void addNOC( + NOCResponseCallback callback, + byte[] NOCValue, + Optional ICACValue, + byte[] IPKValue, + Long caseAdminNode, + Integer adminVendorId, + int timedInvokeTimeoutMs) { + addNOC( + chipClusterPtr, + callback, + NOCValue, + ICACValue, + IPKValue, + caseAdminNode, + adminVendorId, + timedInvokeTimeoutMs); + } + + public void addTrustedRootCertificate(DefaultClusterCallback callback, byte[] rootCertificate) { addTrustedRootCertificate(chipClusterPtr, callback, rootCertificate, null); } - public void addTrustedRootCertificate(DefaultClusterCallback callback - , byte[] rootCertificate - , int timedInvokeTimeoutMs) { + public void addTrustedRootCertificate( + DefaultClusterCallback callback, byte[] rootCertificate, int timedInvokeTimeoutMs) { addTrustedRootCertificate(chipClusterPtr, callback, rootCertificate, timedInvokeTimeoutMs); } - public void attestationRequest(AttestationResponseCallback callback - , byte[] attestationNonce) { + public void attestationRequest(AttestationResponseCallback callback, byte[] attestationNonce) { attestationRequest(chipClusterPtr, callback, attestationNonce, null); } - public void attestationRequest(AttestationResponseCallback callback - , byte[] attestationNonce - , int timedInvokeTimeoutMs) { + public void attestationRequest( + AttestationResponseCallback callback, byte[] attestationNonce, int timedInvokeTimeoutMs) { attestationRequest(chipClusterPtr, callback, attestationNonce, timedInvokeTimeoutMs); } - public void certificateChainRequest(CertificateChainResponseCallback callback - , Integer certificateType) { + public void certificateChainRequest( + CertificateChainResponseCallback callback, Integer certificateType) { certificateChainRequest(chipClusterPtr, callback, certificateType, null); } - public void certificateChainRequest(CertificateChainResponseCallback callback - , Integer certificateType - , int timedInvokeTimeoutMs) { + public void certificateChainRequest( + CertificateChainResponseCallback callback, + Integer certificateType, + int timedInvokeTimeoutMs) { certificateChainRequest(chipClusterPtr, callback, certificateType, timedInvokeTimeoutMs); } - public void opCSRRequest(OpCSRResponseCallback callback - , byte[] CSRNonce) { + public void opCSRRequest(OpCSRResponseCallback callback, byte[] CSRNonce) { opCSRRequest(chipClusterPtr, callback, CSRNonce, null); } - public void opCSRRequest(OpCSRResponseCallback callback - , byte[] CSRNonce - , int timedInvokeTimeoutMs) { + public void opCSRRequest( + OpCSRResponseCallback callback, byte[] CSRNonce, int timedInvokeTimeoutMs) { opCSRRequest(chipClusterPtr, callback, CSRNonce, timedInvokeTimeoutMs); } - public void removeFabric(NOCResponseCallback callback - , Integer fabricIndex) { + public void removeFabric(NOCResponseCallback callback, Integer fabricIndex) { removeFabric(chipClusterPtr, callback, fabricIndex, null); } - public void removeFabric(NOCResponseCallback callback - , Integer fabricIndex - , int timedInvokeTimeoutMs) { + public void removeFabric( + NOCResponseCallback callback, Integer fabricIndex, int timedInvokeTimeoutMs) { removeFabric(chipClusterPtr, callback, fabricIndex, timedInvokeTimeoutMs); } - public void removeTrustedRootCertificate(DefaultClusterCallback callback - , byte[] trustedRootIdentifier) { + public void removeTrustedRootCertificate( + DefaultClusterCallback callback, byte[] trustedRootIdentifier) { removeTrustedRootCertificate(chipClusterPtr, callback, trustedRootIdentifier, null); } - public void removeTrustedRootCertificate(DefaultClusterCallback callback - , byte[] trustedRootIdentifier - , int timedInvokeTimeoutMs) { - removeTrustedRootCertificate(chipClusterPtr, callback, trustedRootIdentifier, timedInvokeTimeoutMs); + public void removeTrustedRootCertificate( + DefaultClusterCallback callback, byte[] trustedRootIdentifier, int timedInvokeTimeoutMs) { + removeTrustedRootCertificate( + chipClusterPtr, callback, trustedRootIdentifier, timedInvokeTimeoutMs); } - public void updateFabricLabel(NOCResponseCallback callback - , String label) { + public void updateFabricLabel(NOCResponseCallback callback, String label) { updateFabricLabel(chipClusterPtr, callback, label, null); } - public void updateFabricLabel(NOCResponseCallback callback - , String label - , int timedInvokeTimeoutMs) { + public void updateFabricLabel( + NOCResponseCallback callback, String label, int timedInvokeTimeoutMs) { updateFabricLabel(chipClusterPtr, callback, label, timedInvokeTimeoutMs); } - public void updateNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue) { + public void updateNOC( + NOCResponseCallback callback, byte[] NOCValue, Optional ICACValue) { updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, null); } - public void updateNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue - , int timedInvokeTimeoutMs) { + public void updateNOC( + NOCResponseCallback callback, + byte[] NOCValue, + Optional ICACValue, + int timedInvokeTimeoutMs) { updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, timedInvokeTimeoutMs); } - private native void addNOC(long chipClusterPtr, NOCResponseCallback Callback - , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId - , @Nullable Integer timedInvokeTimeoutMs); - private native void addTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback Callback - , byte[] rootCertificate - , @Nullable Integer timedInvokeTimeoutMs); - private native void attestationRequest(long chipClusterPtr, AttestationResponseCallback Callback - , byte[] attestationNonce - , @Nullable Integer timedInvokeTimeoutMs); - private native void certificateChainRequest(long chipClusterPtr, CertificateChainResponseCallback Callback - , Integer certificateType - , @Nullable Integer timedInvokeTimeoutMs); - private native void opCSRRequest(long chipClusterPtr, OpCSRResponseCallback Callback - , byte[] CSRNonce - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeFabric(long chipClusterPtr, NOCResponseCallback Callback - , Integer fabricIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback Callback - , byte[] trustedRootIdentifier - , @Nullable Integer timedInvokeTimeoutMs); - private native void updateFabricLabel(long chipClusterPtr, NOCResponseCallback Callback - , String label - , @Nullable Integer timedInvokeTimeoutMs); - private native void updateNOC(long chipClusterPtr, NOCResponseCallback Callback - , byte[] NOCValue, Optional ICACValue - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addNOC( + long chipClusterPtr, + NOCResponseCallback Callback, + byte[] NOCValue, + Optional ICACValue, + byte[] IPKValue, + Long caseAdminNode, + Integer adminVendorId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void addTrustedRootCertificate( + long chipClusterPtr, + DefaultClusterCallback Callback, + byte[] rootCertificate, + @Nullable Integer timedInvokeTimeoutMs); + + private native void attestationRequest( + long chipClusterPtr, + AttestationResponseCallback Callback, + byte[] attestationNonce, + @Nullable Integer timedInvokeTimeoutMs); + + private native void certificateChainRequest( + long chipClusterPtr, + CertificateChainResponseCallback Callback, + Integer certificateType, + @Nullable Integer timedInvokeTimeoutMs); + + private native void opCSRRequest( + long chipClusterPtr, + OpCSRResponseCallback Callback, + byte[] CSRNonce, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeFabric( + long chipClusterPtr, + NOCResponseCallback Callback, + Integer fabricIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeTrustedRootCertificate( + long chipClusterPtr, + DefaultClusterCallback Callback, + byte[] trustedRootIdentifier, + @Nullable Integer timedInvokeTimeoutMs); + + private native void updateFabricLabel( + long chipClusterPtr, + NOCResponseCallback Callback, + String label, + @Nullable Integer timedInvokeTimeoutMs); + + private native void updateNOC( + long chipClusterPtr, + NOCResponseCallback Callback, + byte[] NOCValue, + Optional ICACValue, + @Nullable Integer timedInvokeTimeoutMs); + public interface AttestationResponseCallback { void onSuccess(byte[] attestationElements, byte[] signature); @@ -9330,184 +10262,177 @@ public interface OpCSRResponseCallback { void onError(Exception error); } + public interface NOCsAttributeCallback { + void onSuccess(List valueList); - public interface NOCsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface FabricsListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface TrustedRootCertificatesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentFabricIndexAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface FabricsListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface TrustedRootCertificatesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readNOCsAttribute( - NOCsAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public interface CurrentFabricIndexAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readNOCsAttribute(NOCsAttributeCallback callback) { readNOCsAttribute(chipClusterPtr, callback); } + public void subscribeNOCsAttribute( - NOCsAttributeCallback callback - , - int minInterval, int maxInterval) { + NOCsAttributeCallback callback, int minInterval, int maxInterval) { subscribeNOCsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFabricsListAttribute( - FabricsListAttributeCallback callback - ) { + public void readFabricsListAttribute(FabricsListAttributeCallback callback) { readFabricsListAttribute(chipClusterPtr, callback); } + public void subscribeFabricsListAttribute( - FabricsListAttributeCallback callback - , - int minInterval, int maxInterval) { + FabricsListAttributeCallback callback, int minInterval, int maxInterval) { subscribeFabricsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedFabricsAttribute( - IntegerAttributeCallback callback - ) { + public void readSupportedFabricsAttribute(IntegerAttributeCallback callback) { readSupportedFabricsAttribute(chipClusterPtr, callback); } + public void subscribeSupportedFabricsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCommissionedFabricsAttribute( - IntegerAttributeCallback callback - ) { + public void readCommissionedFabricsAttribute(IntegerAttributeCallback callback) { readCommissionedFabricsAttribute(chipClusterPtr, callback); } + public void subscribeCommissionedFabricsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCommissionedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTrustedRootCertificatesAttribute( - TrustedRootCertificatesAttributeCallback callback - ) { + TrustedRootCertificatesAttributeCallback callback) { readTrustedRootCertificatesAttribute(chipClusterPtr, callback); } + public void subscribeTrustedRootCertificatesAttribute( - TrustedRootCertificatesAttributeCallback callback - , - int minInterval, int maxInterval) { + TrustedRootCertificatesAttributeCallback callback, int minInterval, int maxInterval) { subscribeTrustedRootCertificatesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentFabricIndexAttribute( - CurrentFabricIndexAttributeCallback callback - ) { + public void readCurrentFabricIndexAttribute(CurrentFabricIndexAttributeCallback callback) { readCurrentFabricIndexAttribute(chipClusterPtr, callback); } + public void subscribeCurrentFabricIndexAttribute( - CurrentFabricIndexAttributeCallback callback - , - int minInterval, int maxInterval) { + CurrentFabricIndexAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNOCsAttribute(long chipClusterPtr, - NOCsAttributeCallback callback - ); - private native void subscribeNOCsAttribute(long chipClusterPtr, - NOCsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readFabricsListAttribute(long chipClusterPtr, - FabricsListAttributeCallback callback - ); - private native void subscribeFabricsListAttribute(long chipClusterPtr, - FabricsListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readSupportedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSupportedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCommissionedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCommissionedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTrustedRootCertificatesAttribute(long chipClusterPtr, - TrustedRootCertificatesAttributeCallback callback - ); - private native void subscribeTrustedRootCertificatesAttribute(long chipClusterPtr, - TrustedRootCertificatesAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentFabricIndexAttribute(long chipClusterPtr, - CurrentFabricIndexAttributeCallback callback - ); - private native void subscribeCurrentFabricIndexAttribute(long chipClusterPtr, - CurrentFabricIndexAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readNOCsAttribute(long chipClusterPtr, NOCsAttributeCallback callback); + + private native void subscribeNOCsAttribute( + long chipClusterPtr, NOCsAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFabricsListAttribute( + long chipClusterPtr, FabricsListAttributeCallback callback); + + private native void subscribeFabricsListAttribute( + long chipClusterPtr, + FabricsListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSupportedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSupportedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCommissionedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCommissionedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTrustedRootCertificatesAttribute( + long chipClusterPtr, TrustedRootCertificatesAttributeCallback callback); + + private native void subscribeTrustedRootCertificatesAttribute( + long chipClusterPtr, + TrustedRootCertificatesAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentFabricIndexAttribute( + long chipClusterPtr, CurrentFabricIndexAttributeCallback callback); + + private native void subscribeCurrentFabricIndexAttribute( + long chipClusterPtr, + CurrentFabricIndexAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class PowerSourceCluster extends BaseChipCluster { @@ -9520,244 +10445,208 @@ public PowerSourceCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface ActiveBatteryFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface ActiveBatteryFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readStatusAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readStatusAttribute(IntegerAttributeCallback callback) { readStatusAttribute(chipClusterPtr, callback); } + public void subscribeStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOrderAttribute( - IntegerAttributeCallback callback - ) { + public void readOrderAttribute(IntegerAttributeCallback callback) { readOrderAttribute(chipClusterPtr, callback); } + public void subscribeOrderAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOrderAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDescriptionAttribute( - CharStringAttributeCallback callback - ) { + public void readDescriptionAttribute(CharStringAttributeCallback callback) { readDescriptionAttribute(chipClusterPtr, callback); } + public void subscribeDescriptionAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryVoltageAttribute( - LongAttributeCallback callback - ) { + public void readBatteryVoltageAttribute(LongAttributeCallback callback) { readBatteryVoltageAttribute(chipClusterPtr, callback); } + public void subscribeBatteryVoltageAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryPercentRemainingAttribute( - IntegerAttributeCallback callback - ) { + public void readBatteryPercentRemainingAttribute(IntegerAttributeCallback callback) { readBatteryPercentRemainingAttribute(chipClusterPtr, callback); } + public void subscribeBatteryPercentRemainingAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryPercentRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryTimeRemainingAttribute( - LongAttributeCallback callback - ) { + public void readBatteryTimeRemainingAttribute(LongAttributeCallback callback) { readBatteryTimeRemainingAttribute(chipClusterPtr, callback); } + public void subscribeBatteryTimeRemainingAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryTimeRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryChargeLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readBatteryChargeLevelAttribute(IntegerAttributeCallback callback) { readBatteryChargeLevelAttribute(chipClusterPtr, callback); } + public void subscribeBatteryChargeLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryChargeLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveBatteryFaultsAttribute( - ActiveBatteryFaultsAttributeCallback callback - ) { + public void readActiveBatteryFaultsAttribute(ActiveBatteryFaultsAttributeCallback callback) { readActiveBatteryFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveBatteryFaultsAttribute( - ActiveBatteryFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveBatteryFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveBatteryFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryChargeStateAttribute( - IntegerAttributeCallback callback - ) { + public void readBatteryChargeStateAttribute(IntegerAttributeCallback callback) { readBatteryChargeStateAttribute(chipClusterPtr, callback); } + public void subscribeBatteryChargeStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryChargeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOrderAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOrderAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryVoltageAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBatteryVoltageAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryPercentRemainingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBatteryPercentRemainingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryTimeRemainingAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBatteryTimeRemainingAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryChargeLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBatteryChargeLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveBatteryFaultsAttribute(long chipClusterPtr, - ActiveBatteryFaultsAttributeCallback callback - ); - private native void subscribeActiveBatteryFaultsAttribute(long chipClusterPtr, - ActiveBatteryFaultsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readBatteryChargeStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBatteryChargeStateAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readStatusAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOrderAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOrderAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDescriptionAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeDescriptionAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readBatteryVoltageAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBatteryVoltageAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBatteryPercentRemainingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBatteryPercentRemainingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBatteryTimeRemainingAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBatteryTimeRemainingAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBatteryChargeLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBatteryChargeLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveBatteryFaultsAttribute( + long chipClusterPtr, ActiveBatteryFaultsAttributeCallback callback); + + private native void subscribeActiveBatteryFaultsAttribute( + long chipClusterPtr, + ActiveBatteryFaultsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readBatteryChargeStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBatteryChargeStateAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 PowerSourceConfigurationCluster extends BaseChipCluster { @@ -9770,73 +10659,69 @@ public PowerSourceConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SourcesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface SourcesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readSourcesAttribute( - SourcesAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readSourcesAttribute(SourcesAttributeCallback callback) { readSourcesAttribute(chipClusterPtr, callback); } + public void subscribeSourcesAttribute( - SourcesAttributeCallback callback - , - int minInterval, int maxInterval) { + SourcesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSourcesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSourcesAttribute(long chipClusterPtr, - SourcesAttributeCallback callback - ); - private native void subscribeSourcesAttribute(long chipClusterPtr, - SourcesAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readSourcesAttribute( + long chipClusterPtr, SourcesAttributeCallback callback); + + private native void subscribeSourcesAttribute( + long chipClusterPtr, SourcesAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class PressureMeasurementCluster extends BaseChipCluster { @@ -9849,106 +10734,91 @@ public PressureMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class PumpConfigurationAndControlCluster extends BaseChipCluster { @@ -9961,701 +10831,614 @@ public PumpConfigurationAndControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LifetimeRunningHoursAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface LifetimeEnergyConsumedAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface LifetimeRunningHoursAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface LifetimeEnergyConsumedAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); - public void readMaxPressureAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMaxPressureAttribute(IntegerAttributeCallback callback) { readMaxPressureAttribute(chipClusterPtr, callback); } + public void subscribeMaxPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxSpeedAttribute(IntegerAttributeCallback callback) { readMaxSpeedAttribute(chipClusterPtr, callback); } + public void subscribeMaxSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxFlowAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxFlowAttribute(IntegerAttributeCallback callback) { readMaxFlowAttribute(chipClusterPtr, callback); } + public void subscribeMaxFlowAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstPressureAttribute(IntegerAttributeCallback callback) { readMinConstPressureAttribute(chipClusterPtr, callback); } + public void subscribeMinConstPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstPressureAttribute(IntegerAttributeCallback callback) { readMaxConstPressureAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinCompPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMinCompPressureAttribute(IntegerAttributeCallback callback) { readMinCompPressureAttribute(chipClusterPtr, callback); } + public void subscribeMinCompPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxCompPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxCompPressureAttribute(IntegerAttributeCallback callback) { readMaxCompPressureAttribute(chipClusterPtr, callback); } + public void subscribeMaxCompPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstSpeedAttribute(IntegerAttributeCallback callback) { readMinConstSpeedAttribute(chipClusterPtr, callback); } + public void subscribeMinConstSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstSpeedAttribute(IntegerAttributeCallback callback) { readMaxConstSpeedAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstFlowAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstFlowAttribute(IntegerAttributeCallback callback) { readMinConstFlowAttribute(chipClusterPtr, callback); } + public void subscribeMinConstFlowAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstFlowAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstFlowAttribute(IntegerAttributeCallback callback) { readMaxConstFlowAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstFlowAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstTempAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstTempAttribute(IntegerAttributeCallback callback) { readMinConstTempAttribute(chipClusterPtr, callback); } + public void subscribeMinConstTempAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstTempAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstTempAttribute(IntegerAttributeCallback callback) { readMaxConstTempAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstTempAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPumpStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readPumpStatusAttribute(IntegerAttributeCallback callback) { readPumpStatusAttribute(chipClusterPtr, callback); } + public void subscribePumpStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePumpStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEffectiveOperationModeAttribute( - IntegerAttributeCallback callback - ) { + public void readEffectiveOperationModeAttribute(IntegerAttributeCallback callback) { readEffectiveOperationModeAttribute(chipClusterPtr, callback); } + public void subscribeEffectiveOperationModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEffectiveOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEffectiveControlModeAttribute( - IntegerAttributeCallback callback - ) { + public void readEffectiveControlModeAttribute(IntegerAttributeCallback callback) { readEffectiveControlModeAttribute(chipClusterPtr, callback); } + public void subscribeEffectiveControlModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEffectiveControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCapacityAttribute( - IntegerAttributeCallback callback - ) { + public void readCapacityAttribute(IntegerAttributeCallback callback) { readCapacityAttribute(chipClusterPtr, callback); } + public void subscribeCapacityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readSpeedAttribute(IntegerAttributeCallback callback) { readSpeedAttribute(chipClusterPtr, callback); } + public void subscribeSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLifetimeRunningHoursAttribute( - LifetimeRunningHoursAttributeCallback callback - ) { + public void readLifetimeRunningHoursAttribute(LifetimeRunningHoursAttributeCallback callback) { readLifetimeRunningHoursAttribute(chipClusterPtr, callback); } + public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value) { writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, null); } - public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeLifetimeRunningHoursAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLifetimeRunningHoursAttribute( - LifetimeRunningHoursAttributeCallback callback - , - int minInterval, int maxInterval) { + LifetimeRunningHoursAttributeCallback callback, int minInterval, int maxInterval) { subscribeLifetimeRunningHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPowerAttribute( - LongAttributeCallback callback - ) { + public void readPowerAttribute(LongAttributeCallback callback) { readPowerAttribute(chipClusterPtr, callback); } + public void subscribePowerAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readLifetimeEnergyConsumedAttribute( - LifetimeEnergyConsumedAttributeCallback callback - ) { + LifetimeEnergyConsumedAttributeCallback callback) { readLifetimeEnergyConsumedAttribute(chipClusterPtr, callback); } + public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value) { writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, null); } - public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeLifetimeEnergyConsumedAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLifetimeEnergyConsumedAttribute( - LifetimeEnergyConsumedAttributeCallback callback - , - int minInterval, int maxInterval) { + LifetimeEnergyConsumedAttributeCallback callback, int minInterval, int maxInterval) { subscribeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperationModeAttribute( - IntegerAttributeCallback callback - ) { + public void readOperationModeAttribute(IntegerAttributeCallback callback) { readOperationModeAttribute(chipClusterPtr, callback); } + public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value) { writeOperationModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOperationModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOperationModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOperationModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readControlModeAttribute( - IntegerAttributeCallback callback - ) { + public void readControlModeAttribute(IntegerAttributeCallback callback) { readControlModeAttribute(chipClusterPtr, callback); } + public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value) { writeControlModeAttribute(chipClusterPtr, callback, value, null); } - public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeControlModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeControlModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeControlModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAlarmMaskAttribute( - IntegerAttributeCallback callback - ) { + public void readAlarmMaskAttribute(IntegerAttributeCallback callback) { readAlarmMaskAttribute(chipClusterPtr, callback); } + public void subscribeAlarmMaskAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAlarmMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMaxPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPumpStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePumpStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEffectiveOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEffectiveOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEffectiveControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEffectiveControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCapacityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCapacityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLifetimeRunningHoursAttribute(long chipClusterPtr, - LifetimeRunningHoursAttributeCallback callback - ); - - private native void writeLifetimeRunningHoursAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLifetimeRunningHoursAttribute(long chipClusterPtr, - LifetimeRunningHoursAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readPowerAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePowerAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLifetimeEnergyConsumedAttribute(long chipClusterPtr, - LifetimeEnergyConsumedAttributeCallback callback - ); - - private native void writeLifetimeEnergyConsumedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLifetimeEnergyConsumedAttribute(long chipClusterPtr, - LifetimeEnergyConsumedAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOperationModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeControlModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAlarmMaskAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAlarmMaskAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); - } + private native void readMaxPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public static class RelativeHumidityMeasurementCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1029L; + private native void subscribeMaxPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void readMaxSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - @Override - public native long initWithDevice(long devicePtr, int endpointId); + private native void subscribeMaxSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void readMaxFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { - readMeasuredValueAttribute(chipClusterPtr, callback); - } - public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeMaxFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { - readMinMeasuredValueAttribute(chipClusterPtr, callback); - } - public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readMinConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { - readMaxMeasuredValueAttribute(chipClusterPtr, callback); - } - public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeMinConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { - readToleranceAttribute(chipClusterPtr, callback); - } - public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readMaxConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { - readAttributeListAttribute(chipClusterPtr, callback); - } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeMaxConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { - readClusterRevisionAttribute(chipClusterPtr, callback); + private native void readMinCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPumpStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePumpStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEffectiveOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEffectiveOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEffectiveControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEffectiveControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCapacityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCapacityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSpeedAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLifetimeRunningHoursAttribute( + long chipClusterPtr, LifetimeRunningHoursAttributeCallback callback); + + private native void writeLifetimeRunningHoursAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLifetimeRunningHoursAttribute( + long chipClusterPtr, + LifetimeRunningHoursAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPowerAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePowerAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLifetimeEnergyConsumedAttribute( + long chipClusterPtr, LifetimeEnergyConsumedAttributeCallback callback); + + private native void writeLifetimeEnergyConsumedAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLifetimeEnergyConsumedAttribute( + long chipClusterPtr, + LifetimeEnergyConsumedAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOperationModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeControlModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAlarmMaskAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAlarmMaskAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 RelativeHumidityMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1029L; + + public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + + public void subscribeMeasuredValueAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + + public void subscribeMinMeasuredValueAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + + public void subscribeMaxMeasuredValueAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readToleranceAttribute(IntegerAttributeCallback callback) { + readToleranceAttribute(chipClusterPtr, callback); + } + + public void subscribeToleranceAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeToleranceAttribute(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 readClusterRevisionAttribute(IntegerAttributeCallback callback) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ScenesCluster extends BaseChipCluster { @@ -10668,103 +11451,163 @@ public ScenesCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addScene(AddSceneResponseCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { - addScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, sceneName, extensionFieldSets, null); - } - - public void addScene(AddSceneResponseCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets - , int timedInvokeTimeoutMs) { - addScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, sceneName, extensionFieldSets, timedInvokeTimeoutMs); - } - - public void getSceneMembership(GetSceneMembershipResponseCallback callback - , Integer groupId) { + public void addScene( + AddSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets) { + addScene( + chipClusterPtr, + callback, + groupId, + sceneId, + transitionTime, + sceneName, + extensionFieldSets, + null); + } + + public void addScene( + AddSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets, + int timedInvokeTimeoutMs) { + addScene( + chipClusterPtr, + callback, + groupId, + sceneId, + transitionTime, + sceneName, + extensionFieldSets, + timedInvokeTimeoutMs); + } + + public void getSceneMembership(GetSceneMembershipResponseCallback callback, Integer groupId) { getSceneMembership(chipClusterPtr, callback, groupId, null); } - public void getSceneMembership(GetSceneMembershipResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void getSceneMembership( + GetSceneMembershipResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { getSceneMembership(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void recallScene(DefaultClusterCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime) { + public void recallScene( + DefaultClusterCallback callback, Integer groupId, Integer sceneId, Integer transitionTime) { recallScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, null); } - public void recallScene(DefaultClusterCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime - , int timedInvokeTimeoutMs) { + public void recallScene( + DefaultClusterCallback callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + int timedInvokeTimeoutMs) { recallScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, timedInvokeTimeoutMs); } - public void removeAllScenes(RemoveAllScenesResponseCallback callback - , Integer groupId) { + public void removeAllScenes(RemoveAllScenesResponseCallback callback, Integer groupId) { removeAllScenes(chipClusterPtr, callback, groupId, null); } - public void removeAllScenes(RemoveAllScenesResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void removeAllScenes( + RemoveAllScenesResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { removeAllScenes(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void removeScene(RemoveSceneResponseCallback callback - , Integer groupId, Integer sceneId) { + public void removeScene( + RemoveSceneResponseCallback callback, Integer groupId, Integer sceneId) { removeScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void removeScene(RemoveSceneResponseCallback callback - , Integer groupId, Integer sceneId - , int timedInvokeTimeoutMs) { + public void removeScene( + RemoveSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + int timedInvokeTimeoutMs) { removeScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - public void storeScene(StoreSceneResponseCallback callback - , Integer groupId, Integer sceneId) { + public void storeScene(StoreSceneResponseCallback callback, Integer groupId, Integer sceneId) { storeScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void storeScene(StoreSceneResponseCallback callback - , Integer groupId, Integer sceneId - , int timedInvokeTimeoutMs) { + public void storeScene( + StoreSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + int timedInvokeTimeoutMs) { storeScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - public void viewScene(ViewSceneResponseCallback callback - , Integer groupId, Integer sceneId) { + public void viewScene(ViewSceneResponseCallback callback, Integer groupId, Integer sceneId) { viewScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void viewScene(ViewSceneResponseCallback callback - , Integer groupId, Integer sceneId - , int timedInvokeTimeoutMs) { + public void viewScene( + ViewSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + int timedInvokeTimeoutMs) { viewScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - private native void addScene(long chipClusterPtr, AddSceneResponseCallback Callback - , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets - , @Nullable Integer timedInvokeTimeoutMs); - private native void getSceneMembership(long chipClusterPtr, GetSceneMembershipResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); - private native void recallScene(long chipClusterPtr, DefaultClusterCallback Callback - , Integer groupId, Integer sceneId, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeAllScenes(long chipClusterPtr, RemoveAllScenesResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeScene(long chipClusterPtr, RemoveSceneResponseCallback Callback - , Integer groupId, Integer sceneId - , @Nullable Integer timedInvokeTimeoutMs); - private native void storeScene(long chipClusterPtr, StoreSceneResponseCallback Callback - , Integer groupId, Integer sceneId - , @Nullable Integer timedInvokeTimeoutMs); - private native void viewScene(long chipClusterPtr, ViewSceneResponseCallback Callback - , Integer groupId, Integer sceneId - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addScene( + long chipClusterPtr, + AddSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getSceneMembership( + long chipClusterPtr, + GetSceneMembershipResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void recallScene( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeAllScenes( + long chipClusterPtr, + RemoveAllScenesResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeScene( + long chipClusterPtr, + RemoveSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void storeScene( + long chipClusterPtr, + StoreSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void viewScene( + long chipClusterPtr, + ViewSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + @Nullable Integer timedInvokeTimeoutMs); + public interface AddSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); @@ -10772,7 +11615,12 @@ public interface AddSceneResponseCallback { } public interface GetSceneMembershipResponseCallback { - void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList); + void onSuccess( + Integer status, + Integer capacity, + Integer groupId, + Integer sceneCount, + ArrayList sceneList); void onError(Exception error); } @@ -10796,150 +11644,132 @@ public interface StoreSceneResponseCallback { } public interface ViewSceneResponseCallback { - void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets); + void onSuccess( + Integer status, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readSceneCountAttribute( - IntegerAttributeCallback callback - ) { + public void readSceneCountAttribute(IntegerAttributeCallback callback) { readSceneCountAttribute(chipClusterPtr, callback); } + public void subscribeSceneCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSceneCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentSceneAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentSceneAttribute(IntegerAttributeCallback callback) { readCurrentSceneAttribute(chipClusterPtr, callback); } + public void subscribeCurrentSceneAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentSceneAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentGroupAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentGroupAttribute(IntegerAttributeCallback callback) { readCurrentGroupAttribute(chipClusterPtr, callback); } + public void subscribeCurrentGroupAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentGroupAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSceneValidAttribute( - BooleanAttributeCallback callback - ) { + public void readSceneValidAttribute(BooleanAttributeCallback callback) { readSceneValidAttribute(chipClusterPtr, callback); } + public void subscribeSceneValidAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeSceneValidAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNameSupportAttribute( - IntegerAttributeCallback callback - ) { + public void readNameSupportAttribute(IntegerAttributeCallback callback) { readNameSupportAttribute(chipClusterPtr, callback); } + public void subscribeNameSupportAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSceneCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSceneCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentSceneAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentSceneAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentGroupAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentGroupAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSceneValidAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeSceneValidAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readSceneCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSceneCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentSceneAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentSceneAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentGroupAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentGroupAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSceneValidAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeSceneValidAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class SoftwareDiagnosticsCluster extends BaseChipCluster { @@ -10952,163 +11782,147 @@ public SoftwareDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetWatermarks(DefaultClusterCallback callback - ) { + public void resetWatermarks(DefaultClusterCallback callback) { resetWatermarks(chipClusterPtr, callback, null); } - public void resetWatermarks(DefaultClusterCallback callback + public void resetWatermarks(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { resetWatermarks(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void resetWatermarks(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void resetWatermarks( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface ThreadMetricsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface ThreadMetricsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readThreadMetricsAttribute( - ThreadMetricsAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readThreadMetricsAttribute(ThreadMetricsAttributeCallback callback) { readThreadMetricsAttribute(chipClusterPtr, callback); } + public void subscribeThreadMetricsAttribute( - ThreadMetricsAttributeCallback callback - , - int minInterval, int maxInterval) { + ThreadMetricsAttributeCallback callback, int minInterval, int maxInterval) { subscribeThreadMetricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapFreeAttribute( - LongAttributeCallback callback - ) { + public void readCurrentHeapFreeAttribute(LongAttributeCallback callback) { readCurrentHeapFreeAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHeapFreeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentHeapFreeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapUsedAttribute( - LongAttributeCallback callback - ) { + public void readCurrentHeapUsedAttribute(LongAttributeCallback callback) { readCurrentHeapUsedAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHeapUsedAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentHeapUsedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapHighWatermarkAttribute( - LongAttributeCallback callback - ) { + public void readCurrentHeapHighWatermarkAttribute(LongAttributeCallback callback) { readCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHeapHighWatermarkAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCurrentHeapHighWatermarkAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readThreadMetricsAttribute(long chipClusterPtr, - ThreadMetricsAttributeCallback callback - ); - private native void subscribeThreadMetricsAttribute(long chipClusterPtr, - ThreadMetricsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentHeapFreeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentHeapFreeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentHeapUsedAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentHeapUsedAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentHeapHighWatermarkAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentHeapHighWatermarkAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readThreadMetricsAttribute( + long chipClusterPtr, ThreadMetricsAttributeCallback callback); + + private native void subscribeThreadMetricsAttribute( + long chipClusterPtr, + ThreadMetricsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentHeapFreeAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentHeapFreeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentHeapUsedAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentHeapUsedAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentHeapHighWatermarkAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentHeapHighWatermarkAttribute( + long chipClusterPtr, LongAttributeCallback 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 SwitchCluster extends BaseChipCluster { @@ -11121,125 +11935,106 @@ public SwitchCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readNumberOfPositionsAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfPositionsAttribute(IntegerAttributeCallback callback) { readNumberOfPositionsAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfPositionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNumberOfPositionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentPositionAttribute(IntegerAttributeCallback callback) { readCurrentPositionAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMultiPressMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readMultiPressMaxAttribute(IntegerAttributeCallback callback) { readMultiPressMaxAttribute(chipClusterPtr, callback); } + public void subscribeMultiPressMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMultiPressMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNumberOfPositionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfPositionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMultiPressMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMultiPressMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readNumberOfPositionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfPositionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMultiPressMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMultiPressMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 TargetNavigatorCluster extends BaseChipCluster { @@ -11252,112 +12047,113 @@ public TargetNavigatorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void navigateTargetRequest(NavigateTargetResponseCallback callback - , Integer target, String data) { + public void navigateTargetRequest( + NavigateTargetResponseCallback callback, Integer target, String data) { navigateTargetRequest(chipClusterPtr, callback, target, data, null); } - public void navigateTargetRequest(NavigateTargetResponseCallback callback - , Integer target, String data - , int timedInvokeTimeoutMs) { + public void navigateTargetRequest( + NavigateTargetResponseCallback callback, + Integer target, + String data, + int timedInvokeTimeoutMs) { navigateTargetRequest(chipClusterPtr, callback, target, data, timedInvokeTimeoutMs); } - private native void navigateTargetRequest(long chipClusterPtr, NavigateTargetResponseCallback Callback - , Integer target, String data - , @Nullable Integer timedInvokeTimeoutMs); + + private native void navigateTargetRequest( + long chipClusterPtr, + NavigateTargetResponseCallback Callback, + Integer target, + String data, + @Nullable Integer timedInvokeTimeoutMs); + public interface NavigateTargetResponseCallback { void onSuccess(Integer status, String data); void onError(Exception error); } + public interface TargetNavigatorListAttributeCallback { + void onSuccess(List valueList); - public interface TargetNavigatorListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readTargetNavigatorListAttribute( - TargetNavigatorListAttributeCallback callback - ) { + public void readTargetNavigatorListAttribute(TargetNavigatorListAttributeCallback callback) { readTargetNavigatorListAttribute(chipClusterPtr, callback); } + public void subscribeTargetNavigatorListAttribute( - TargetNavigatorListAttributeCallback callback - , - int minInterval, int maxInterval) { + TargetNavigatorListAttributeCallback callback, int minInterval, int maxInterval) { subscribeTargetNavigatorListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentNavigatorTargetAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentNavigatorTargetAttribute(IntegerAttributeCallback callback) { readCurrentNavigatorTargetAttribute(chipClusterPtr, callback); } + public void subscribeCurrentNavigatorTargetAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentNavigatorTargetAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTargetNavigatorListAttribute(long chipClusterPtr, - TargetNavigatorListAttributeCallback callback - ); - private native void subscribeTargetNavigatorListAttribute(long chipClusterPtr, - TargetNavigatorListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentNavigatorTargetAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentNavigatorTargetAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readTargetNavigatorListAttribute( + long chipClusterPtr, TargetNavigatorListAttributeCallback callback); + + private native void subscribeTargetNavigatorListAttribute( + long chipClusterPtr, + TargetNavigatorListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentNavigatorTargetAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentNavigatorTargetAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class TemperatureMeasurementCluster extends BaseChipCluster { @@ -11370,2838 +12166,3268 @@ public TemperatureMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { + public void readToleranceAttribute(IntegerAttributeCallback callback) { readToleranceAttribute(chipClusterPtr, callback); } + public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class TestClusterCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1295L; + + public TestClusterCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void simpleStructEchoRequest( + SimpleStructResponseCallback callback, ChipStructs.TestClusterClusterSimpleStruct arg1) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, null); + } + + public void simpleStructEchoRequest( + SimpleStructResponseCallback callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + int timedInvokeTimeoutMs) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void test(DefaultClusterCallback callback) { + test(chipClusterPtr, callback, null); + } + + public void test(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + test(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testAddArguments( + TestAddArgumentsResponseCallback callback, Integer arg1, Integer arg2) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, null); + } + + public void testAddArguments( + TestAddArgumentsResponseCallback callback, + Integer arg1, + Integer arg2, + int timedInvokeTimeoutMs) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + } + + public void testEmitTestEventRequest( + TestEmitTestEventResponseCallback callback, Integer arg1, Integer arg2, Boolean arg3) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, null); + } + + public void testEmitTestEventRequest( + TestEmitTestEventResponseCallback callback, + Integer arg1, + Integer arg2, + Boolean arg3, + int timedInvokeTimeoutMs) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, timedInvokeTimeoutMs); + } + + public void testEnumsRequest(TestEnumsResponseCallback callback, Integer arg1, Integer arg2) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, null); + } + + public void testEnumsRequest( + TestEnumsResponseCallback callback, Integer arg1, Integer arg2, int timedInvokeTimeoutMs) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + } + + public void testListInt8UArgumentRequest( + BooleanResponseCallback callback, ArrayList arg1) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListInt8UArgumentRequest( + BooleanResponseCallback callback, ArrayList arg1, int timedInvokeTimeoutMs) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListInt8UReverseRequest( + TestListInt8UReverseResponseCallback callback, ArrayList arg1) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListInt8UReverseRequest( + TestListInt8UReverseResponseCallback callback, + ArrayList arg1, + int timedInvokeTimeoutMs) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListNestedStructListArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListNestedStructListArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1, + int timedInvokeTimeoutMs) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListStructArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListStructArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1, + int timedInvokeTimeoutMs) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testNestedStructArgumentRequest( + BooleanResponseCallback callback, ChipStructs.TestClusterClusterNestedStruct arg1) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNestedStructArgumentRequest( + BooleanResponseCallback callback, + ChipStructs.TestClusterClusterNestedStruct arg1, + int timedInvokeTimeoutMs) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testNestedStructListArgumentRequest( + BooleanResponseCallback callback, ChipStructs.TestClusterClusterNestedStructList arg1) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNestedStructListArgumentRequest( + BooleanResponseCallback callback, + ChipStructs.TestClusterClusterNestedStructList arg1, + int timedInvokeTimeoutMs) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testNotHandled(DefaultClusterCallback callback) { + testNotHandled(chipClusterPtr, callback, null); + } + + public void testNotHandled(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testNullableOptionalRequest( + TestNullableOptionalResponseCallback callback, @Nullable Optional arg1) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNullableOptionalRequest( + TestNullableOptionalResponseCallback callback, + @Nullable Optional arg1, + int timedInvokeTimeoutMs) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testSimpleOptionalArgumentRequest( + DefaultClusterCallback callback, Optional arg1) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testSimpleOptionalArgumentRequest( + DefaultClusterCallback callback, Optional arg1, int timedInvokeTimeoutMs) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testSpecific(TestSpecificResponseCallback callback) { + testSpecific(chipClusterPtr, callback, null); + } + + public void testSpecific(TestSpecificResponseCallback callback, int timedInvokeTimeoutMs) { + + testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testStructArgumentRequest( + BooleanResponseCallback callback, ChipStructs.TestClusterClusterSimpleStruct arg1) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testStructArgumentRequest( + BooleanResponseCallback callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + int timedInvokeTimeoutMs) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testUnknownCommand(DefaultClusterCallback callback) { + testUnknownCommand(chipClusterPtr, callback, null); + } + + public void testUnknownCommand(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void timedInvokeRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + private native void simpleStructEchoRequest( + long chipClusterPtr, + SimpleStructResponseCallback Callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void test( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testAddArguments( + long chipClusterPtr, + TestAddArgumentsResponseCallback Callback, + Integer arg1, + Integer arg2, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testEmitTestEventRequest( + long chipClusterPtr, + TestEmitTestEventResponseCallback Callback, + Integer arg1, + Integer arg2, + Boolean arg3, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testEnumsRequest( + long chipClusterPtr, + TestEnumsResponseCallback Callback, + Integer arg1, + Integer arg2, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListInt8UArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListInt8UReverseRequest( + long chipClusterPtr, + TestListInt8UReverseResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListNestedStructListArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListStructArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNestedStructArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ChipStructs.TestClusterClusterNestedStruct arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNestedStructListArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ChipStructs.TestClusterClusterNestedStructList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNotHandled( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNullableOptionalRequest( + long chipClusterPtr, + TestNullableOptionalResponseCallback Callback, + @Nullable Optional arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testSimpleOptionalArgumentRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Optional arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testSpecific( + long chipClusterPtr, + TestSpecificResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testStructArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testUnknownCommand( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void timedInvokeRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface BooleanResponseCallback { + void onSuccess(Boolean value); + + void onError(Exception error); + } + + public interface SimpleStructResponseCallback { + void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); + + void onError(Exception error); + } + + public interface TestAddArgumentsResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } + + public interface TestEmitTestEventResponseCallback { + void onSuccess(Long value); + + void onError(Exception error); + } + + public interface TestEnumsResponseCallback { + void onSuccess(Integer arg1, Integer arg2); + + void onError(Exception error); + } + + public interface TestListInt8UReverseResponseCallback { + void onSuccess(ArrayList arg1); + + void onError(Exception error); + } + + public interface TestNullableOptionalResponseCallback { + void onSuccess( + Boolean wasPresent, + Optional wasNull, + Optional value, + @Nullable Optional originalValue); + + void onError(Exception error); + } + + public interface TestSpecificResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } + + public interface ListInt8uAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListOctetStringAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListStructOctetStringAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface VendorIdAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListNullablesAndOptionalsStructAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListLongOctetStringAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBooleanAttributeCallback { + void onSuccess(@Nullable Boolean value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBitmap8AttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBitmap16AttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBitmap32AttributeCallback { + void onSuccess(@Nullable Long value); - public static class TestClusterCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1295L; + void onError(Exception ex); - public TestClusterCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); + default void onSubscriptionEstablished() {} } - @Override - public native long initWithDevice(long devicePtr, int endpointId); + public interface NullableBitmap64AttributeCallback { + void onSuccess(@Nullable Long value); - public void simpleStructEchoRequest(SimpleStructResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1) { - simpleStructEchoRequest(chipClusterPtr, callback, arg1, null); - } + void onError(Exception ex); - public void simpleStructEchoRequest(SimpleStructResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , int timedInvokeTimeoutMs) { - simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void test(DefaultClusterCallback callback - ) { - test(chipClusterPtr, callback, null); - } + public interface NullableInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); - public void test(DefaultClusterCallback callback + void onError(Exception ex); - , int timedInvokeTimeoutMs) { - test(chipClusterPtr, callback, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testAddArguments(TestAddArgumentsResponseCallback callback - , Integer arg1, Integer arg2) { - testAddArguments(chipClusterPtr, callback, arg1, arg2, null); - } + public interface NullableInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); - public void testAddArguments(TestAddArgumentsResponseCallback callback - , Integer arg1, Integer arg2 - , int timedInvokeTimeoutMs) { - testAddArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); - } + void onError(Exception ex); - public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback - , Integer arg1, Integer arg2, Boolean arg3) { - testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, null); + default void onSubscriptionEstablished() {} } - public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback - , Integer arg1, Integer arg2, Boolean arg3 - , int timedInvokeTimeoutMs) { - testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, timedInvokeTimeoutMs); - } + public interface NullableInt24uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testEnumsRequest(TestEnumsResponseCallback callback - , Integer arg1, Integer arg2) { - testEnumsRequest(chipClusterPtr, callback, arg1, arg2, null); - } + void onError(Exception ex); - public void testEnumsRequest(TestEnumsResponseCallback callback - , Integer arg1, Integer arg2 - , int timedInvokeTimeoutMs) { - testEnumsRequest(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testListInt8UArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1) { - testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null); - } + public interface NullableInt32uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testListInt8UArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + void onError(Exception ex); - public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback - , ArrayList arg1) { - testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null); + default void onSubscriptionEstablished() {} } - public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListInt8UReverseRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + public interface NullableInt40uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1) { - testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); - } + void onError(Exception ex); - public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testListStructArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1) { - testListStructArgumentRequest(chipClusterPtr, callback, arg1, null); - } + public interface NullableInt48uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testListStructArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + void onError(Exception ex); - public void testNestedStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStruct arg1) { - testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null); + default void onSubscriptionEstablished() {} } - public void testNestedStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStruct arg1 - , int timedInvokeTimeoutMs) { - testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + public interface NullableInt56uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testNestedStructListArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStructList arg1) { - testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); - } + void onError(Exception ex); - public void testNestedStructListArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStructList arg1 - , int timedInvokeTimeoutMs) { - testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testNotHandled(DefaultClusterCallback callback - ) { - testNotHandled(chipClusterPtr, callback, null); - } + public interface NullableInt64uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testNotHandled(DefaultClusterCallback callback + void onError(Exception ex); - , int timedInvokeTimeoutMs) { - testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback - , @Nullable Optional arg1) { - testNullableOptionalRequest(chipClusterPtr, callback, arg1, null); + public interface NullableInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback - , @Nullable Optional arg1 - , int timedInvokeTimeoutMs) { - testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + public interface NullableInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback - , Optional arg1) { - testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null); + public interface NullableInt24sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback - , Optional arg1 - , int timedInvokeTimeoutMs) { - testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + public interface NullableInt32sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSpecific(TestSpecificResponseCallback callback - ) { - testSpecific(chipClusterPtr, callback, null); + public interface NullableInt40sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSpecific(TestSpecificResponseCallback callback + public interface NullableInt48sAttributeCallback { + void onSuccess(@Nullable Long value); - , int timedInvokeTimeoutMs) { - testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1) { - testStructArgumentRequest(chipClusterPtr, callback, arg1, null); + public interface NullableInt56sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , int timedInvokeTimeoutMs) { - testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + public interface NullableInt64sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testUnknownCommand(DefaultClusterCallback callback - ) { - testUnknownCommand(chipClusterPtr, callback, null); + public interface NullableEnum8AttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testUnknownCommand(DefaultClusterCallback callback + public interface NullableEnum16AttributeCallback { + void onSuccess(@Nullable Integer value); - , int timedInvokeTimeoutMs) { - testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } + public interface NullableFloatSingleAttributeCallback { + void onSuccess(@Nullable Float value); - public void timedInvokeRequest(DefaultClusterCallback callback + void onError(Exception ex); - , int timedInvokeTimeoutMs) { - timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - private native void simpleStructEchoRequest(long chipClusterPtr, SimpleStructResponseCallback Callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void test(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void testAddArguments(long chipClusterPtr, TestAddArgumentsResponseCallback Callback - , Integer arg1, Integer arg2 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testEmitTestEventRequest(long chipClusterPtr, TestEmitTestEventResponseCallback Callback - , Integer arg1, Integer arg2, Boolean arg3 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testEnumsRequest(long chipClusterPtr, TestEnumsResponseCallback Callback - , Integer arg1, Integer arg2 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListInt8UArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListInt8UReverseRequest(long chipClusterPtr, TestListInt8UReverseResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNestedStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ChipStructs.TestClusterClusterNestedStruct arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ChipStructs.TestClusterClusterNestedStructList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNotHandled(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNullableOptionalRequest(long chipClusterPtr, TestNullableOptionalResponseCallback Callback - , @Nullable Optional arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testSimpleOptionalArgumentRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Optional arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testSpecific(long chipClusterPtr, TestSpecificResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void testStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testUnknownCommand(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void timedInvokeRequest(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - public interface BooleanResponseCallback { - void onSuccess(Boolean value); - void onError(Exception error); + public interface NullableFloatDoubleAttributeCallback { + void onSuccess(@Nullable Double value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface SimpleStructResponseCallback { - void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); + public interface NullableOctetStringAttributeCallback { + void onSuccess(@Nullable byte[] value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestAddArgumentsResponseCallback { - void onSuccess(Integer returnValue); + public interface NullableCharStringAttributeCallback { + void onSuccess(@Nullable String value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestEmitTestEventResponseCallback { - void onSuccess(Long value); + public interface NullableEnumAttrAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestEnumsResponseCallback { - void onSuccess(Integer arg1, Integer arg2); + public interface NullableRangeRestrictedInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestListInt8UReverseResponseCallback { - void onSuccess(ArrayList arg1); + public interface NullableRangeRestrictedInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestNullableOptionalResponseCallback { - void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue); + public interface NullableRangeRestrictedInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestSpecificResponseCallback { - void onSuccess(Integer returnValue); + public interface NullableRangeRestrictedInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface ListInt8uAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListOctetStringAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListStructOctetStringAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface VendorIdAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListNullablesAndOptionalsStructAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListLongOctetStringAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBooleanAttributeCallback { - void onSuccess(@Nullable Boolean value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap8AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap16AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap32AttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap64AttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt8uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt16uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt24uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt32uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt40uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt48uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt56uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt64uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt8sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt16sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt24sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt32sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt40sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt48sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt56sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt64sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableEnum8AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableEnum16AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableFloatSingleAttributeCallback { - void onSuccess(@Nullable Float value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableFloatDoubleAttributeCallback { - void onSuccess(@Nullable Double value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableOctetStringAttributeCallback { - void onSuccess(@Nullable byte[] value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableCharStringAttributeCallback { - void onSuccess(@Nullable String value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableEnumAttrAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt8uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt8sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt16uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt16sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readBooleanAttribute(BooleanAttributeCallback callback) { readBooleanAttribute(chipClusterPtr, callback); } + public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap8Attribute( - IntegerAttributeCallback callback - ) { + public void readBitmap8Attribute(IntegerAttributeCallback callback) { readBitmap8Attribute(chipClusterPtr, callback); } + public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value) { writeBitmap8Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeBitmap8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap8Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap16Attribute( - IntegerAttributeCallback callback - ) { + public void readBitmap16Attribute(IntegerAttributeCallback callback) { readBitmap16Attribute(chipClusterPtr, callback); } + public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value) { writeBitmap16Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeBitmap16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap16Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap32Attribute( - LongAttributeCallback callback - ) { + public void readBitmap32Attribute(LongAttributeCallback callback) { readBitmap32Attribute(chipClusterPtr, callback); } + public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value) { writeBitmap32Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBitmap32Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap32Attribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap64Attribute( - LongAttributeCallback callback - ) { + public void readBitmap64Attribute(LongAttributeCallback callback) { readBitmap64Attribute(chipClusterPtr, callback); } + public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value) { writeBitmap64Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBitmap64Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap64Attribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt8uAttribute( - IntegerAttributeCallback callback - ) { + public void readInt8uAttribute(IntegerAttributeCallback callback) { readInt8uAttribute(chipClusterPtr, callback); } + public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt8uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt16uAttribute( - IntegerAttributeCallback callback - ) { + public void readInt16uAttribute(IntegerAttributeCallback callback) { readInt16uAttribute(chipClusterPtr, callback); } + public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt16uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt24uAttribute( - LongAttributeCallback callback - ) { + public void readInt24uAttribute(LongAttributeCallback callback) { readInt24uAttribute(chipClusterPtr, callback); } + public void writeInt24uAttribute(DefaultClusterCallback callback, Long value) { writeInt24uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt24uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt24uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt32uAttribute( - LongAttributeCallback callback - ) { + public void readInt32uAttribute(LongAttributeCallback callback) { readInt32uAttribute(chipClusterPtr, callback); } + public void writeInt32uAttribute(DefaultClusterCallback callback, Long value) { writeInt32uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt32uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt32uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt40uAttribute( - LongAttributeCallback callback - ) { + public void readInt40uAttribute(LongAttributeCallback callback) { readInt40uAttribute(chipClusterPtr, callback); } + public void writeInt40uAttribute(DefaultClusterCallback callback, Long value) { writeInt40uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt40uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt40uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt48uAttribute( - LongAttributeCallback callback - ) { + public void readInt48uAttribute(LongAttributeCallback callback) { readInt48uAttribute(chipClusterPtr, callback); } + public void writeInt48uAttribute(DefaultClusterCallback callback, Long value) { writeInt48uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt48uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt48uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt56uAttribute( - LongAttributeCallback callback - ) { + public void readInt56uAttribute(LongAttributeCallback callback) { readInt56uAttribute(chipClusterPtr, callback); } + public void writeInt56uAttribute(DefaultClusterCallback callback, Long value) { writeInt56uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt56uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt56uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt64uAttribute( - LongAttributeCallback callback - ) { + public void readInt64uAttribute(LongAttributeCallback callback) { readInt64uAttribute(chipClusterPtr, callback); } + public void writeInt64uAttribute(DefaultClusterCallback callback, Long value) { writeInt64uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt64uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt64uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt8sAttribute( - IntegerAttributeCallback callback - ) { + public void readInt8sAttribute(IntegerAttributeCallback callback) { readInt8sAttribute(chipClusterPtr, callback); } + public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt8sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt16sAttribute( - IntegerAttributeCallback callback - ) { + public void readInt16sAttribute(IntegerAttributeCallback callback) { readInt16sAttribute(chipClusterPtr, callback); } + public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt16sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt24sAttribute( - LongAttributeCallback callback - ) { + public void readInt24sAttribute(LongAttributeCallback callback) { readInt24sAttribute(chipClusterPtr, callback); } + public void writeInt24sAttribute(DefaultClusterCallback callback, Long value) { writeInt24sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt24sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt24sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt32sAttribute( - LongAttributeCallback callback - ) { + public void readInt32sAttribute(LongAttributeCallback callback) { readInt32sAttribute(chipClusterPtr, callback); } + public void writeInt32sAttribute(DefaultClusterCallback callback, Long value) { writeInt32sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt32sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt32sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt40sAttribute( - LongAttributeCallback callback - ) { + public void readInt40sAttribute(LongAttributeCallback callback) { readInt40sAttribute(chipClusterPtr, callback); } + public void writeInt40sAttribute(DefaultClusterCallback callback, Long value) { writeInt40sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt40sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt40sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt48sAttribute( - LongAttributeCallback callback - ) { + public void readInt48sAttribute(LongAttributeCallback callback) { readInt48sAttribute(chipClusterPtr, callback); } + public void writeInt48sAttribute(DefaultClusterCallback callback, Long value) { writeInt48sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt48sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt48sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt56sAttribute( - LongAttributeCallback callback - ) { + public void readInt56sAttribute(LongAttributeCallback callback) { readInt56sAttribute(chipClusterPtr, callback); } + public void writeInt56sAttribute(DefaultClusterCallback callback, Long value) { writeInt56sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt56sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt56sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt64sAttribute( - LongAttributeCallback callback - ) { + public void readInt64sAttribute(LongAttributeCallback callback) { readInt64sAttribute(chipClusterPtr, callback); } + public void writeInt64sAttribute(DefaultClusterCallback callback, Long value) { writeInt64sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt64sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt64sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnum8Attribute( - IntegerAttributeCallback callback - ) { + public void readEnum8Attribute(IntegerAttributeCallback callback) { readEnum8Attribute(chipClusterPtr, callback); } + public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value) { writeEnum8Attribute(chipClusterPtr, callback, value, null); } - public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnum8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnum8Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnum16Attribute( - IntegerAttributeCallback callback - ) { + public void readEnum16Attribute(IntegerAttributeCallback callback) { readEnum16Attribute(chipClusterPtr, callback); } + public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value) { writeEnum16Attribute(chipClusterPtr, callback, value, null); } - public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnum16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnum16Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFloatSingleAttribute( - FloatAttributeCallback callback - ) { + public void readFloatSingleAttribute(FloatAttributeCallback callback) { readFloatSingleAttribute(chipClusterPtr, callback); } + public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value) { writeFloatSingleAttribute(chipClusterPtr, callback, value, null); } - public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + public void writeFloatSingleAttribute( + DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { writeFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeFloatSingleAttribute( - FloatAttributeCallback callback -, - int minInterval, int maxInterval) { + FloatAttributeCallback callback, int minInterval, int maxInterval) { subscribeFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFloatDoubleAttribute( - DoubleAttributeCallback callback - ) { + public void readFloatDoubleAttribute(DoubleAttributeCallback callback) { readFloatDoubleAttribute(chipClusterPtr, callback); } + public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { writeFloatDoubleAttribute(chipClusterPtr, callback, value, null); } - public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + public void writeFloatDoubleAttribute( + DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { writeFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeFloatDoubleAttribute( - DoubleAttributeCallback callback -, - int minInterval, int maxInterval) { + DoubleAttributeCallback callback, int minInterval, int maxInterval) { subscribeFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOctetStringAttribute( - OctetStringAttributeCallback callback - ) { + public void readOctetStringAttribute(OctetStringAttributeCallback callback) { readOctetStringAttribute(chipClusterPtr, callback); } + public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeOctetStringAttribute( + DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOctetStringAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListInt8uAttribute( - ListInt8uAttributeCallback callback - ) { + public void readListInt8uAttribute(ListInt8uAttributeCallback callback) { readListInt8uAttribute(chipClusterPtr, callback); } + public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value) { writeListInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListInt8uAttribute( + DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListInt8uAttribute( - ListInt8uAttributeCallback callback - , - int minInterval, int maxInterval) { + ListInt8uAttributeCallback callback, int minInterval, int maxInterval) { subscribeListInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListOctetStringAttribute( - ListOctetStringAttributeCallback callback - ) { + public void readListOctetStringAttribute(ListOctetStringAttributeCallback callback) { readListOctetStringAttribute(chipClusterPtr, callback); } - public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeListOctetStringAttribute( + DefaultClusterCallback callback, ArrayList value) { writeListOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListOctetStringAttribute( + DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListOctetStringAttribute( - ListOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + ListOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeListOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readListStructOctetStringAttribute( - ListStructOctetStringAttributeCallback callback - ) { + ListStructOctetStringAttributeCallback callback) { readListStructOctetStringAttribute(chipClusterPtr, callback); } - public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeListStructOctetStringAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeListStructOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListStructOctetStringAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeListStructOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListStructOctetStringAttribute( - ListStructOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + ListStructOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeListStructOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLongOctetStringAttribute( - OctetStringAttributeCallback callback - ) { + public void readLongOctetStringAttribute(OctetStringAttributeCallback callback) { readLongOctetStringAttribute(chipClusterPtr, callback); } + public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeLongOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeLongOctetStringAttribute( + DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeLongOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLongOctetStringAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCharStringAttribute( - CharStringAttributeCallback callback - ) { + public void readCharStringAttribute(CharStringAttributeCallback callback) { readCharStringAttribute(chipClusterPtr, callback); } + public void writeCharStringAttribute(DefaultClusterCallback callback, String value) { writeCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeCharStringAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeCharStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLongCharStringAttribute( - CharStringAttributeCallback callback - ) { + public void readLongCharStringAttribute(CharStringAttributeCallback callback) { readLongCharStringAttribute(chipClusterPtr, callback); } + public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value) { writeLongCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLongCharStringAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLongCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLongCharStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLongCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEpochUsAttribute( - LongAttributeCallback callback - ) { + public void readEpochUsAttribute(LongAttributeCallback callback) { readEpochUsAttribute(chipClusterPtr, callback); } + public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value) { writeEpochUsAttribute(chipClusterPtr, callback, value, null); } - public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeEpochUsAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeEpochUsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEpochUsAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeEpochUsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEpochSAttribute( - LongAttributeCallback callback - ) { + public void readEpochSAttribute(LongAttributeCallback callback) { readEpochSAttribute(chipClusterPtr, callback); } + public void writeEpochSAttribute(DefaultClusterCallback callback, Long value) { writeEpochSAttribute(chipClusterPtr, callback, value, null); } - public void writeEpochSAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeEpochSAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeEpochSAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEpochSAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeEpochSAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIdAttribute( - VendorIdAttributeCallback callback - ) { + public void readVendorIdAttribute(VendorIdAttributeCallback callback) { readVendorIdAttribute(chipClusterPtr, callback); } + public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value) { writeVendorIdAttribute(chipClusterPtr, callback, value, null); } - public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeVendorIdAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeVendorIdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeVendorIdAttribute( - VendorIdAttributeCallback callback - , - int minInterval, int maxInterval) { + VendorIdAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readListNullablesAndOptionalsStructAttribute( - ListNullablesAndOptionalsStructAttributeCallback callback - ) { + ListNullablesAndOptionalsStructAttributeCallback callback) { readListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback); } - public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeListNullablesAndOptionalsStructAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, null); } - public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { - writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeListNullablesAndOptionalsStructAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { + writeListNullablesAndOptionalsStructAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListNullablesAndOptionalsStructAttribute( - ListNullablesAndOptionalsStructAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, minInterval, maxInterval); + ListNullablesAndOptionalsStructAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeListNullablesAndOptionalsStructAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnumAttrAttribute( - IntegerAttributeCallback callback - ) { + public void readEnumAttrAttribute(IntegerAttributeCallback callback) { readEnumAttrAttribute(chipClusterPtr, callback); } + public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { writeEnumAttrAttribute(chipClusterPtr, callback, value, null); } - public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnumAttrAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnumAttrAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt8uAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt8uAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt8uAttribute(chipClusterPtr, callback); } + public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt8uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt8sAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt8sAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt8sAttribute(chipClusterPtr, callback); } + public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt8sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt16uAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt16uAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt16uAttribute(chipClusterPtr, callback); } - public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt16uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt16sAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt16sAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt16sAttribute(chipClusterPtr, callback); } - public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt16sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListLongOctetStringAttribute( - ListLongOctetStringAttributeCallback callback - ) { + public void readListLongOctetStringAttribute(ListLongOctetStringAttributeCallback callback) { readListLongOctetStringAttribute(chipClusterPtr, callback); } + public void subscribeListLongOctetStringAttribute( - ListLongOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + ListLongOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeListLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTimedWriteBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readTimedWriteBooleanAttribute(BooleanAttributeCallback callback) { readTimedWriteBooleanAttribute(chipClusterPtr, callback); } - public void writeTimedWriteBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeTimedWriteBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeTimedWriteBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeTimedWriteBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeTimedWriteBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGeneralErrorBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readGeneralErrorBooleanAttribute(BooleanAttributeCallback callback) { readGeneralErrorBooleanAttribute(chipClusterPtr, callback); } + public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeGeneralErrorBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeGeneralErrorBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeGeneralErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterErrorBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readClusterErrorBooleanAttribute(BooleanAttributeCallback callback) { readClusterErrorBooleanAttribute(chipClusterPtr, callback); } + public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeClusterErrorBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeClusterErrorBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUnsupportedAttribute( - BooleanAttributeCallback callback - ) { + public void readUnsupportedAttribute(BooleanAttributeCallback callback) { readUnsupportedAttribute(chipClusterPtr, callback); } + public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value) { writeUnsupportedAttribute(chipClusterPtr, callback, value, null); } - public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeUnsupportedAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeUnsupportedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeUnsupportedAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeUnsupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBooleanAttribute( - NullableBooleanAttributeCallback callback - ) { + public void readNullableBooleanAttribute(NullableBooleanAttributeCallback callback) { readNullableBooleanAttribute(chipClusterPtr, callback); } + public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeNullableBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeNullableBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeNullableBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBooleanAttribute( - NullableBooleanAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap8Attribute( - NullableBitmap8AttributeCallback callback - ) { + public void readNullableBitmap8Attribute(NullableBitmap8AttributeCallback callback) { readNullableBitmap8Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value) { writeNullableBitmap8Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableBitmap8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap8Attribute( - NullableBitmap8AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap8AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap16Attribute( - NullableBitmap16AttributeCallback callback - ) { + public void readNullableBitmap16Attribute(NullableBitmap16AttributeCallback callback) { readNullableBitmap16Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value) { writeNullableBitmap16Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableBitmap16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap16Attribute( - NullableBitmap16AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap16AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap32Attribute( - NullableBitmap32AttributeCallback callback - ) { + public void readNullableBitmap32Attribute(NullableBitmap32AttributeCallback callback) { readNullableBitmap32Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value) { writeNullableBitmap32Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableBitmap32Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap32Attribute( - NullableBitmap32AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap32AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap64Attribute( - NullableBitmap64AttributeCallback callback - ) { + public void readNullableBitmap64Attribute(NullableBitmap64AttributeCallback callback) { readNullableBitmap64Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value) { writeNullableBitmap64Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableBitmap64Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap64Attribute( - NullableBitmap64AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap64AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt8uAttribute( - NullableInt8uAttributeCallback callback - ) { + public void readNullableInt8uAttribute(NullableInt8uAttributeCallback callback) { readNullableInt8uAttribute(chipClusterPtr, callback); } + public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt8uAttribute( - NullableInt8uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt8uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt16uAttribute( - NullableInt16uAttributeCallback callback - ) { + public void readNullableInt16uAttribute(NullableInt16uAttributeCallback callback) { readNullableInt16uAttribute(chipClusterPtr, callback); } + public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt16uAttribute( - NullableInt16uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt16uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt24uAttribute( - NullableInt24uAttributeCallback callback - ) { + public void readNullableInt24uAttribute(NullableInt24uAttributeCallback callback) { readNullableInt24uAttribute(chipClusterPtr, callback); } + public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt24uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt24uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt24uAttribute( - NullableInt24uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt24uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt32uAttribute( - NullableInt32uAttributeCallback callback - ) { + public void readNullableInt32uAttribute(NullableInt32uAttributeCallback callback) { readNullableInt32uAttribute(chipClusterPtr, callback); } + public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt32uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt32uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt32uAttribute( - NullableInt32uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt32uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt40uAttribute( - NullableInt40uAttributeCallback callback - ) { + public void readNullableInt40uAttribute(NullableInt40uAttributeCallback callback) { readNullableInt40uAttribute(chipClusterPtr, callback); } + public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt40uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt40uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt40uAttribute( - NullableInt40uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt40uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt48uAttribute( - NullableInt48uAttributeCallback callback - ) { + public void readNullableInt48uAttribute(NullableInt48uAttributeCallback callback) { readNullableInt48uAttribute(chipClusterPtr, callback); } + public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt48uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt48uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt48uAttribute( - NullableInt48uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt48uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt56uAttribute( - NullableInt56uAttributeCallback callback - ) { + public void readNullableInt56uAttribute(NullableInt56uAttributeCallback callback) { readNullableInt56uAttribute(chipClusterPtr, callback); } + public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt56uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt56uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt56uAttribute( - NullableInt56uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt56uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt64uAttribute( - NullableInt64uAttributeCallback callback - ) { + public void readNullableInt64uAttribute(NullableInt64uAttributeCallback callback) { readNullableInt64uAttribute(chipClusterPtr, callback); } + public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt64uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt64uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt64uAttribute( - NullableInt64uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt64uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt8sAttribute( - NullableInt8sAttributeCallback callback - ) { + public void readNullableInt8sAttribute(NullableInt8sAttributeCallback callback) { readNullableInt8sAttribute(chipClusterPtr, callback); } + public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt8sAttribute( - NullableInt8sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt8sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt16sAttribute( - NullableInt16sAttributeCallback callback - ) { + public void readNullableInt16sAttribute(NullableInt16sAttributeCallback callback) { readNullableInt16sAttribute(chipClusterPtr, callback); } + public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt16sAttribute( - NullableInt16sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt16sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt24sAttribute( - NullableInt24sAttributeCallback callback - ) { + public void readNullableInt24sAttribute(NullableInt24sAttributeCallback callback) { readNullableInt24sAttribute(chipClusterPtr, callback); } + public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt24sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt24sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt24sAttribute( - NullableInt24sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt24sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt32sAttribute( - NullableInt32sAttributeCallback callback - ) { + public void readNullableInt32sAttribute(NullableInt32sAttributeCallback callback) { readNullableInt32sAttribute(chipClusterPtr, callback); } + public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt32sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt32sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt32sAttribute( - NullableInt32sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt32sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt40sAttribute( - NullableInt40sAttributeCallback callback - ) { + public void readNullableInt40sAttribute(NullableInt40sAttributeCallback callback) { readNullableInt40sAttribute(chipClusterPtr, callback); } + public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt40sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt40sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt40sAttribute( - NullableInt40sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt40sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt48sAttribute( - NullableInt48sAttributeCallback callback - ) { + public void readNullableInt48sAttribute(NullableInt48sAttributeCallback callback) { readNullableInt48sAttribute(chipClusterPtr, callback); } + public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt48sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt48sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt48sAttribute( - NullableInt48sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt48sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt56sAttribute( - NullableInt56sAttributeCallback callback - ) { + public void readNullableInt56sAttribute(NullableInt56sAttributeCallback callback) { readNullableInt56sAttribute(chipClusterPtr, callback); } + public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt56sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt56sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt56sAttribute( - NullableInt56sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt56sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt64sAttribute( - NullableInt64sAttributeCallback callback - ) { + public void readNullableInt64sAttribute(NullableInt64sAttributeCallback callback) { readNullableInt64sAttribute(chipClusterPtr, callback); } + public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt64sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt64sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt64sAttribute( - NullableInt64sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt64sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnum8Attribute( - NullableEnum8AttributeCallback callback - ) { + public void readNullableEnum8Attribute(NullableEnum8AttributeCallback callback) { readNullableEnum8Attribute(chipClusterPtr, callback); } + public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value) { writeNullableEnum8Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnum8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableEnum8Attribute( - NullableEnum8AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableEnum8AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnum16Attribute( - NullableEnum16AttributeCallback callback - ) { + public void readNullableEnum16Attribute(NullableEnum16AttributeCallback callback) { readNullableEnum16Attribute(chipClusterPtr, callback); } + public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value) { writeNullableEnum16Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnum16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableEnum16Attribute( - NullableEnum16AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableEnum16AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableFloatSingleAttribute( - NullableFloatSingleAttributeCallback callback - ) { + public void readNullableFloatSingleAttribute(NullableFloatSingleAttributeCallback callback) { readNullableFloatSingleAttribute(chipClusterPtr, callback); } + public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value) { writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + public void writeNullableFloatSingleAttribute( + DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableFloatSingleAttribute( - NullableFloatSingleAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableFloatSingleAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableFloatDoubleAttribute( - NullableFloatDoubleAttributeCallback callback - ) { + public void readNullableFloatDoubleAttribute(NullableFloatDoubleAttributeCallback callback) { readNullableFloatDoubleAttribute(chipClusterPtr, callback); } + public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + public void writeNullableFloatDoubleAttribute( + DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableFloatDoubleAttribute( - NullableFloatDoubleAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableFloatDoubleAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableOctetStringAttribute( - NullableOctetStringAttributeCallback callback - ) { + public void readNullableOctetStringAttribute(NullableOctetStringAttributeCallback callback) { readNullableOctetStringAttribute(chipClusterPtr, callback); } + public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeNullableOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeNullableOctetStringAttribute( + DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeNullableOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableOctetStringAttribute( - NullableOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableCharStringAttribute( - NullableCharStringAttributeCallback callback - ) { + public void readNullableCharStringAttribute(NullableCharStringAttributeCallback callback) { readNullableCharStringAttribute(chipClusterPtr, callback); } + public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value) { writeNullableCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeNullableCharStringAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeNullableCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableCharStringAttribute( - NullableCharStringAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableCharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnumAttrAttribute( - NullableEnumAttrAttributeCallback callback - ) { + public void readNullableEnumAttrAttribute(NullableEnumAttrAttributeCallback callback) { readNullableEnumAttrAttribute(chipClusterPtr, callback); } + public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnumAttrAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableEnumAttrAttribute( - NullableEnumAttrAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableEnumAttrAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt8uAttribute( - NullableRangeRestrictedInt8uAttributeCallback callback - ) { + NullableRangeRestrictedInt8uAttributeCallback callback) { readNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8uAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt8uAttribute( - NullableRangeRestrictedInt8uAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt8uAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8uAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt8sAttribute( - NullableRangeRestrictedInt8sAttributeCallback callback - ) { + NullableRangeRestrictedInt8sAttributeCallback callback) { readNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8sAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt8sAttribute( - NullableRangeRestrictedInt8sAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt8sAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8sAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt16uAttribute( - NullableRangeRestrictedInt16uAttributeCallback callback - ) { + NullableRangeRestrictedInt16uAttributeCallback callback) { readNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16uAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt16uAttribute( - NullableRangeRestrictedInt16uAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt16uAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16uAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt16sAttribute( - NullableRangeRestrictedInt16sAttributeCallback callback - ) { + NullableRangeRestrictedInt16sAttributeCallback callback) { readNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16sAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt16sAttribute( - NullableRangeRestrictedInt16sAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt16sAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16sAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap32Attribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap32Attribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap64Attribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap64Attribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt24uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt24uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt32uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt32uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt40uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt40uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt48uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt48uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt56uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt56uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt64uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt64uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt24sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt24sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt32sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt32sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt40sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt40sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt48sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt48sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt56sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt56sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt64sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt64sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnum8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnum8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnum16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnum16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readFloatSingleAttribute(long chipClusterPtr, - FloatAttributeCallback callback - ); - - private native void writeFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeFloatSingleAttribute(long chipClusterPtr, - FloatAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readFloatDoubleAttribute(long chipClusterPtr, - DoubleAttributeCallback callback - ); - - private native void writeFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeFloatDoubleAttribute(long chipClusterPtr, - DoubleAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - - private native void writeOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readListInt8uAttribute(long chipClusterPtr, - ListInt8uAttributeCallback callback - ); - - private native void writeListInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListInt8uAttribute(long chipClusterPtr, - ListInt8uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readListOctetStringAttribute(long chipClusterPtr, - ListOctetStringAttributeCallback callback - ); - - private native void writeListOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListOctetStringAttribute(long chipClusterPtr, - ListOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readListStructOctetStringAttribute(long chipClusterPtr, - ListStructOctetStringAttributeCallback callback - ); - - private native void writeListStructOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListStructOctetStringAttribute(long chipClusterPtr, - ListStructOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readLongOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - - private native void writeLongOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLongOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLongCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeLongCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLongCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEpochUsAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeEpochUsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEpochUsAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEpochSAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeEpochSAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEpochSAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorIdAttribute(long chipClusterPtr, - VendorIdAttributeCallback callback - ); - - private native void writeVendorIdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeVendorIdAttribute(long chipClusterPtr, - VendorIdAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readListNullablesAndOptionalsStructAttribute(long chipClusterPtr, - ListNullablesAndOptionalsStructAttributeCallback callback - ); - - private native void writeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, - ListNullablesAndOptionalsStructAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readEnumAttrAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnumAttrAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readListLongOctetStringAttribute(long chipClusterPtr, - ListLongOctetStringAttributeCallback callback - ); - private native void subscribeListLongOctetStringAttribute(long chipClusterPtr, - ListLongOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readTimedWriteBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeTimedWriteBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeTimedWriteBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readGeneralErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeGeneralErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeGeneralErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readClusterErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeClusterErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeClusterErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUnsupportedAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeUnsupportedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeUnsupportedAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNullableBooleanAttribute(long chipClusterPtr, - NullableBooleanAttributeCallback callback - ); - - private native void writeNullableBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBooleanAttribute(long chipClusterPtr, - NullableBooleanAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap8Attribute(long chipClusterPtr, - NullableBitmap8AttributeCallback callback - ); - - private native void writeNullableBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap8Attribute(long chipClusterPtr, - NullableBitmap8AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap16Attribute(long chipClusterPtr, - NullableBitmap16AttributeCallback callback - ); - - private native void writeNullableBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap16Attribute(long chipClusterPtr, - NullableBitmap16AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap32Attribute(long chipClusterPtr, - NullableBitmap32AttributeCallback callback - ); - - private native void writeNullableBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap32Attribute(long chipClusterPtr, - NullableBitmap32AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap64Attribute(long chipClusterPtr, - NullableBitmap64AttributeCallback callback - ); - - private native void writeNullableBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap64Attribute(long chipClusterPtr, - NullableBitmap64AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt8uAttribute(long chipClusterPtr, - NullableInt8uAttributeCallback callback - ); - - private native void writeNullableInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt8uAttribute(long chipClusterPtr, - NullableInt8uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt16uAttribute(long chipClusterPtr, - NullableInt16uAttributeCallback callback - ); - - private native void writeNullableInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt16uAttribute(long chipClusterPtr, - NullableInt16uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt24uAttribute(long chipClusterPtr, - NullableInt24uAttributeCallback callback - ); - - private native void writeNullableInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt24uAttribute(long chipClusterPtr, - NullableInt24uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt32uAttribute(long chipClusterPtr, - NullableInt32uAttributeCallback callback - ); - - private native void writeNullableInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt32uAttribute(long chipClusterPtr, - NullableInt32uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt40uAttribute(long chipClusterPtr, - NullableInt40uAttributeCallback callback - ); - - private native void writeNullableInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt40uAttribute(long chipClusterPtr, - NullableInt40uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt48uAttribute(long chipClusterPtr, - NullableInt48uAttributeCallback callback - ); - - private native void writeNullableInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt48uAttribute(long chipClusterPtr, - NullableInt48uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt56uAttribute(long chipClusterPtr, - NullableInt56uAttributeCallback callback - ); - - private native void writeNullableInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt56uAttribute(long chipClusterPtr, - NullableInt56uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt64uAttribute(long chipClusterPtr, - NullableInt64uAttributeCallback callback - ); - - private native void writeNullableInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt64uAttribute(long chipClusterPtr, - NullableInt64uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt8sAttribute(long chipClusterPtr, - NullableInt8sAttributeCallback callback - ); - - private native void writeNullableInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt8sAttribute(long chipClusterPtr, - NullableInt8sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt16sAttribute(long chipClusterPtr, - NullableInt16sAttributeCallback callback - ); - - private native void writeNullableInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt16sAttribute(long chipClusterPtr, - NullableInt16sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt24sAttribute(long chipClusterPtr, - NullableInt24sAttributeCallback callback - ); - - private native void writeNullableInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt24sAttribute(long chipClusterPtr, - NullableInt24sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt32sAttribute(long chipClusterPtr, - NullableInt32sAttributeCallback callback - ); - - private native void writeNullableInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt32sAttribute(long chipClusterPtr, - NullableInt32sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt40sAttribute(long chipClusterPtr, - NullableInt40sAttributeCallback callback - ); - - private native void writeNullableInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt40sAttribute(long chipClusterPtr, - NullableInt40sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt48sAttribute(long chipClusterPtr, - NullableInt48sAttributeCallback callback - ); - - private native void writeNullableInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt48sAttribute(long chipClusterPtr, - NullableInt48sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt56sAttribute(long chipClusterPtr, - NullableInt56sAttributeCallback callback - ); - - private native void writeNullableInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt56sAttribute(long chipClusterPtr, - NullableInt56sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt64sAttribute(long chipClusterPtr, - NullableInt64sAttributeCallback callback - ); - - private native void writeNullableInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt64sAttribute(long chipClusterPtr, - NullableInt64sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableEnum8Attribute(long chipClusterPtr, - NullableEnum8AttributeCallback callback - ); - - private native void writeNullableEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableEnum8Attribute(long chipClusterPtr, - NullableEnum8AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableEnum16Attribute(long chipClusterPtr, - NullableEnum16AttributeCallback callback - ); - - private native void writeNullableEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableEnum16Attribute(long chipClusterPtr, - NullableEnum16AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableFloatSingleAttribute(long chipClusterPtr, - NullableFloatSingleAttributeCallback callback - ); - - private native void writeNullableFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableFloatSingleAttribute(long chipClusterPtr, - NullableFloatSingleAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableFloatDoubleAttribute(long chipClusterPtr, - NullableFloatDoubleAttributeCallback callback - ); - - private native void writeNullableFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableFloatDoubleAttribute(long chipClusterPtr, - NullableFloatDoubleAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableOctetStringAttribute(long chipClusterPtr, - NullableOctetStringAttributeCallback callback - ); - - private native void writeNullableOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableOctetStringAttribute(long chipClusterPtr, - NullableOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableCharStringAttribute(long chipClusterPtr, - NullableCharStringAttributeCallback callback - ); - - private native void writeNullableCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableCharStringAttribute(long chipClusterPtr, - NullableCharStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableEnumAttrAttribute(long chipClusterPtr, - NullableEnumAttrAttributeCallback callback - ); - - private native void writeNullableEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableEnumAttrAttribute(long chipClusterPtr, - NullableEnumAttrAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8uAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8sAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16uAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16sAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16sAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap8Attribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeBitmap8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap8Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap16Attribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeBitmap16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap16Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap32Attribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeBitmap32Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap32Attribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap64Attribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeBitmap64Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap64Attribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt8uAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt16uAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt24uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt24uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt24uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt32uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt32uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt32uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt40uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt40uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt40uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt48uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt48uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt48uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt56uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt56uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt56uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt64uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt64uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt64uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt8sAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt16sAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt24sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt24sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt24sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt32sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt32sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt32sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt40sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt40sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt40sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt48sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt48sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt48sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt56sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt56sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt56sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt64sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt64sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt64sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnum8Attribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeEnum8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnum8Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnum16Attribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeEnum16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnum16Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFloatSingleAttribute( + long chipClusterPtr, FloatAttributeCallback callback); + + private native void writeFloatSingleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Float value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeFloatSingleAttribute( + long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFloatDoubleAttribute( + long chipClusterPtr, DoubleAttributeCallback callback); + + private native void writeFloatDoubleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Double value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeFloatDoubleAttribute( + long chipClusterPtr, DoubleAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOctetStringAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void writeOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + byte[] value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOctetStringAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readListInt8uAttribute( + long chipClusterPtr, ListInt8uAttributeCallback callback); + + private native void writeListInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListInt8uAttribute( + long chipClusterPtr, ListInt8uAttributeCallback callback, int minInterval, int maxInterval); + + private native void readListOctetStringAttribute( + long chipClusterPtr, ListOctetStringAttributeCallback callback); + + private native void writeListOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListOctetStringAttribute( + long chipClusterPtr, + ListOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readListStructOctetStringAttribute( + long chipClusterPtr, ListStructOctetStringAttributeCallback callback); + + private native void writeListStructOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListStructOctetStringAttribute( + long chipClusterPtr, + ListStructOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLongOctetStringAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void writeLongOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + byte[] value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLongOctetStringAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCharStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeCharStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeCharStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLongCharStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeLongCharStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLongCharStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEpochUsAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeEpochUsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEpochUsAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEpochSAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeEpochSAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEpochSAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readVendorIdAttribute( + long chipClusterPtr, VendorIdAttributeCallback callback); + + private native void writeVendorIdAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeVendorIdAttribute( + long chipClusterPtr, VendorIdAttributeCallback callback, int minInterval, int maxInterval); + + private native void readListNullablesAndOptionalsStructAttribute( + long chipClusterPtr, ListNullablesAndOptionalsStructAttributeCallback callback); + + private native void writeListNullablesAndOptionalsStructAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListNullablesAndOptionalsStructAttribute( + long chipClusterPtr, + ListNullablesAndOptionalsStructAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEnumAttrAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeEnumAttrAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnumAttrAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readListLongOctetStringAttribute( + long chipClusterPtr, ListLongOctetStringAttributeCallback callback); + + private native void subscribeListLongOctetStringAttribute( + long chipClusterPtr, + ListLongOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readTimedWriteBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeTimedWriteBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeTimedWriteBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readGeneralErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeGeneralErrorBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeGeneralErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readClusterErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeClusterErrorBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeClusterErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUnsupportedAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeUnsupportedAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeUnsupportedAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNullableBooleanAttribute( + long chipClusterPtr, NullableBooleanAttributeCallback callback); + + private native void writeNullableBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBooleanAttribute( + long chipClusterPtr, + NullableBooleanAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap8Attribute( + long chipClusterPtr, NullableBitmap8AttributeCallback callback); + + private native void writeNullableBitmap8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap8Attribute( + long chipClusterPtr, + NullableBitmap8AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap16Attribute( + long chipClusterPtr, NullableBitmap16AttributeCallback callback); + + private native void writeNullableBitmap16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap16Attribute( + long chipClusterPtr, + NullableBitmap16AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap32Attribute( + long chipClusterPtr, NullableBitmap32AttributeCallback callback); + + private native void writeNullableBitmap32Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap32Attribute( + long chipClusterPtr, + NullableBitmap32AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap64Attribute( + long chipClusterPtr, NullableBitmap64AttributeCallback callback); + + private native void writeNullableBitmap64Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap64Attribute( + long chipClusterPtr, + NullableBitmap64AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt8uAttribute( + long chipClusterPtr, NullableInt8uAttributeCallback callback); + + private native void writeNullableInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt8uAttribute( + long chipClusterPtr, + NullableInt8uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt16uAttribute( + long chipClusterPtr, NullableInt16uAttributeCallback callback); + + private native void writeNullableInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt16uAttribute( + long chipClusterPtr, + NullableInt16uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt24uAttribute( + long chipClusterPtr, NullableInt24uAttributeCallback callback); + + private native void writeNullableInt24uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt24uAttribute( + long chipClusterPtr, + NullableInt24uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt32uAttribute( + long chipClusterPtr, NullableInt32uAttributeCallback callback); + + private native void writeNullableInt32uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt32uAttribute( + long chipClusterPtr, + NullableInt32uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt40uAttribute( + long chipClusterPtr, NullableInt40uAttributeCallback callback); + + private native void writeNullableInt40uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt40uAttribute( + long chipClusterPtr, + NullableInt40uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt48uAttribute( + long chipClusterPtr, NullableInt48uAttributeCallback callback); + + private native void writeNullableInt48uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt48uAttribute( + long chipClusterPtr, + NullableInt48uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt56uAttribute( + long chipClusterPtr, NullableInt56uAttributeCallback callback); + + private native void writeNullableInt56uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt56uAttribute( + long chipClusterPtr, + NullableInt56uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt64uAttribute( + long chipClusterPtr, NullableInt64uAttributeCallback callback); + + private native void writeNullableInt64uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt64uAttribute( + long chipClusterPtr, + NullableInt64uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt8sAttribute( + long chipClusterPtr, NullableInt8sAttributeCallback callback); + + private native void writeNullableInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt8sAttribute( + long chipClusterPtr, + NullableInt8sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt16sAttribute( + long chipClusterPtr, NullableInt16sAttributeCallback callback); + + private native void writeNullableInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt16sAttribute( + long chipClusterPtr, + NullableInt16sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt24sAttribute( + long chipClusterPtr, NullableInt24sAttributeCallback callback); + + private native void writeNullableInt24sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt24sAttribute( + long chipClusterPtr, + NullableInt24sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt32sAttribute( + long chipClusterPtr, NullableInt32sAttributeCallback callback); + + private native void writeNullableInt32sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt32sAttribute( + long chipClusterPtr, + NullableInt32sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt40sAttribute( + long chipClusterPtr, NullableInt40sAttributeCallback callback); + + private native void writeNullableInt40sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt40sAttribute( + long chipClusterPtr, + NullableInt40sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt48sAttribute( + long chipClusterPtr, NullableInt48sAttributeCallback callback); + + private native void writeNullableInt48sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt48sAttribute( + long chipClusterPtr, + NullableInt48sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt56sAttribute( + long chipClusterPtr, NullableInt56sAttributeCallback callback); + + private native void writeNullableInt56sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt56sAttribute( + long chipClusterPtr, + NullableInt56sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt64sAttribute( + long chipClusterPtr, NullableInt64sAttributeCallback callback); + + private native void writeNullableInt64sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt64sAttribute( + long chipClusterPtr, + NullableInt64sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableEnum8Attribute( + long chipClusterPtr, NullableEnum8AttributeCallback callback); + + private native void writeNullableEnum8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableEnum8Attribute( + long chipClusterPtr, + NullableEnum8AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableEnum16Attribute( + long chipClusterPtr, NullableEnum16AttributeCallback callback); + + private native void writeNullableEnum16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableEnum16Attribute( + long chipClusterPtr, + NullableEnum16AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableFloatSingleAttribute( + long chipClusterPtr, NullableFloatSingleAttributeCallback callback); + + private native void writeNullableFloatSingleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Float value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableFloatSingleAttribute( + long chipClusterPtr, + NullableFloatSingleAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableFloatDoubleAttribute( + long chipClusterPtr, NullableFloatDoubleAttributeCallback callback); + + private native void writeNullableFloatDoubleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Double value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableFloatDoubleAttribute( + long chipClusterPtr, + NullableFloatDoubleAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableOctetStringAttribute( + long chipClusterPtr, NullableOctetStringAttributeCallback callback); + + private native void writeNullableOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + byte[] value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableOctetStringAttribute( + long chipClusterPtr, + NullableOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableCharStringAttribute( + long chipClusterPtr, NullableCharStringAttributeCallback callback); + + private native void writeNullableCharStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableCharStringAttribute( + long chipClusterPtr, + NullableCharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableEnumAttrAttribute( + long chipClusterPtr, NullableEnumAttrAttributeCallback callback); + + private native void writeNullableEnumAttrAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableEnumAttrAttribute( + long chipClusterPtr, + NullableEnumAttrAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, NullableRangeRestrictedInt8uAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt8uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, NullableRangeRestrictedInt8sAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt8sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, NullableRangeRestrictedInt16uAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt16uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, NullableRangeRestrictedInt16sAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt16sAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ThermostatCluster extends BaseChipCluster { @@ -14214,554 +15440,587 @@ public ThermostatCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void clearWeeklySchedule(DefaultClusterCallback callback - ) { + public void clearWeeklySchedule(DefaultClusterCallback callback) { clearWeeklySchedule(chipClusterPtr, callback, null); } - public void clearWeeklySchedule(DefaultClusterCallback callback + public void clearWeeklySchedule(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { clearWeeklySchedule(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback - ) { + public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback) { getRelayStatusLog(chipClusterPtr, callback, null); } - public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback + public void getRelayStatusLog( + GetRelayStatusLogResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { getRelayStatusLog(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback - , Integer daysToReturn, Integer modeToReturn) { + public void getWeeklySchedule( + GetWeeklyScheduleResponseCallback callback, Integer daysToReturn, Integer modeToReturn) { getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, null); } - public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback - , Integer daysToReturn, Integer modeToReturn - , int timedInvokeTimeoutMs) { + public void getWeeklySchedule( + GetWeeklyScheduleResponseCallback callback, + Integer daysToReturn, + Integer modeToReturn, + int timedInvokeTimeoutMs) { getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, timedInvokeTimeoutMs); } - public void setWeeklySchedule(DefaultClusterCallback callback - , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload) { - setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, payload, null); - } - - public void setWeeklySchedule(DefaultClusterCallback callback - , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload - , int timedInvokeTimeoutMs) { - setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, payload, timedInvokeTimeoutMs); - } - - public void setpointRaiseLower(DefaultClusterCallback callback - , Integer mode, Integer amount) { + public void setWeeklySchedule( + DefaultClusterCallback callback, + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload) { + setWeeklySchedule( + chipClusterPtr, + callback, + numberOfTransitionsForSequence, + dayOfWeekForSequence, + modeForSequence, + payload, + null); + } + + public void setWeeklySchedule( + DefaultClusterCallback callback, + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload, + int timedInvokeTimeoutMs) { + setWeeklySchedule( + chipClusterPtr, + callback, + numberOfTransitionsForSequence, + dayOfWeekForSequence, + modeForSequence, + payload, + timedInvokeTimeoutMs); + } + + public void setpointRaiseLower(DefaultClusterCallback callback, Integer mode, Integer amount) { setpointRaiseLower(chipClusterPtr, callback, mode, amount, null); } - public void setpointRaiseLower(DefaultClusterCallback callback - , Integer mode, Integer amount - , int timedInvokeTimeoutMs) { + public void setpointRaiseLower( + DefaultClusterCallback callback, Integer mode, Integer amount, int timedInvokeTimeoutMs) { setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs); } - private native void clearWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void getRelayStatusLog(long chipClusterPtr, GetRelayStatusLogResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void getWeeklySchedule(long chipClusterPtr, GetWeeklyScheduleResponseCallback Callback - , Integer daysToReturn, Integer modeToReturn - , @Nullable Integer timedInvokeTimeoutMs); - private native void setWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload - , @Nullable Integer timedInvokeTimeoutMs); - private native void setpointRaiseLower(long chipClusterPtr, DefaultClusterCallback Callback - , Integer mode, Integer amount - , @Nullable Integer timedInvokeTimeoutMs); + + private native void clearWeeklySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getRelayStatusLog( + long chipClusterPtr, + GetRelayStatusLogResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getWeeklySchedule( + long chipClusterPtr, + GetWeeklyScheduleResponseCallback Callback, + Integer daysToReturn, + Integer modeToReturn, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setWeeklySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setpointRaiseLower( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer mode, + Integer amount, + @Nullable Integer timedInvokeTimeoutMs); + public interface GetRelayStatusLogResponseCallback { - void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries); + void onSuccess( + Integer timeOfDay, + Integer relayStatus, + Integer localTemperature, + Integer humidityInPercentage, + Integer setpoint, + Integer unreadEntries); void onError(Exception error); } public interface GetWeeklyScheduleResponseCallback { - void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload); + void onSuccess( + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readLocalTemperatureAttribute( - IntegerAttributeCallback callback - ) { + public void readLocalTemperatureAttribute(IntegerAttributeCallback callback) { readLocalTemperatureAttribute(chipClusterPtr, callback); } + public void subscribeLocalTemperatureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocalTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMinHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMaxHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMinCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMaxCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupiedCoolingSetpointAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupiedCoolingSetpointAttribute(IntegerAttributeCallback callback) { readOccupiedCoolingSetpointAttribute(chipClusterPtr, callback); } - public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeOccupiedCoolingSetpointAttribute( + DefaultClusterCallback callback, Integer value) { writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, null); } - public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOccupiedCoolingSetpointAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOccupiedCoolingSetpointAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupiedHeatingSetpointAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupiedHeatingSetpointAttribute(IntegerAttributeCallback callback) { readOccupiedHeatingSetpointAttribute(chipClusterPtr, callback); } - public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeOccupiedHeatingSetpointAttribute( + DefaultClusterCallback callback, Integer value) { writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, null); } - public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOccupiedHeatingSetpointAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOccupiedHeatingSetpointAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMinHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readMinHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinHeatSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMaxHeatSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMinCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readMinCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinCoolSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMaxCoolSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinSetpointDeadBandAttribute( - IntegerAttributeCallback callback - ) { + public void readMinSetpointDeadBandAttribute(IntegerAttributeCallback callback) { readMinSetpointDeadBandAttribute(chipClusterPtr, callback); } + public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value) { writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, null); } - public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinSetpointDeadBandAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMinSetpointDeadBandAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinSetpointDeadBandAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readControlSequenceOfOperationAttribute( - IntegerAttributeCallback callback - ) { + public void readControlSequenceOfOperationAttribute(IntegerAttributeCallback callback) { readControlSequenceOfOperationAttribute(chipClusterPtr, callback); } - public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeControlSequenceOfOperationAttribute( + DefaultClusterCallback callback, Integer value) { writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, null); } - public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeControlSequenceOfOperationAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeControlSequenceOfOperationAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeControlSequenceOfOperationAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeControlSequenceOfOperationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeControlSequenceOfOperationAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readSystemModeAttribute( - IntegerAttributeCallback callback - ) { + public void readSystemModeAttribute(IntegerAttributeCallback callback) { readSystemModeAttribute(chipClusterPtr, callback); } + public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value) { writeSystemModeAttribute(chipClusterPtr, callback, value, null); } - public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSystemModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSystemModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeSystemModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSystemModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartOfWeekAttribute( - IntegerAttributeCallback callback - ) { + public void readStartOfWeekAttribute(IntegerAttributeCallback callback) { readStartOfWeekAttribute(chipClusterPtr, callback); } + public void subscribeStartOfWeekAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartOfWeekAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfWeeklyTransitionsAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfWeeklyTransitionsAttribute(IntegerAttributeCallback callback) { readNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfWeeklyTransitionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfWeeklyTransitionsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfDailyTransitionsAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfDailyTransitionsAttribute(IntegerAttributeCallback callback) { readNumberOfDailyTransitionsAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfDailyTransitionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfDailyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfDailyTransitionsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLocalTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLocalTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupiedCoolingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOccupiedCoolingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOccupiedCoolingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupiedHeatingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOccupiedHeatingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOccupiedHeatingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMinHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMaxHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMinCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMaxCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinSetpointDeadBandAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMinSetpointDeadBandAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMinSetpointDeadBandAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readControlSequenceOfOperationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeControlSequenceOfOperationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeControlSequenceOfOperationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSystemModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeSystemModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSystemModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartOfWeekAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStartOfWeekAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfDailyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfDailyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readLocalTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLocalTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupiedCoolingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOccupiedCoolingSetpointAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOccupiedCoolingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupiedHeatingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOccupiedHeatingSetpointAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOccupiedHeatingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMinHeatSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMaxHeatSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMinCoolSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMaxCoolSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinSetpointDeadBandAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMinSetpointDeadBandAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMinSetpointDeadBandAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readControlSequenceOfOperationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeControlSequenceOfOperationAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeControlSequenceOfOperationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSystemModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeSystemModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSystemModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartOfWeekAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStartOfWeekAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfWeeklyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfWeeklyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfDailyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfDailyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 ThermostatUserInterfaceConfigurationCluster extends BaseChipCluster { @@ -14774,1443 +16033,1237 @@ public ThermostatUserInterfaceConfigurationCluster(long devicePtr, int endpointI @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readTemperatureDisplayModeAttribute( - IntegerAttributeCallback callback - ) { + public void readTemperatureDisplayModeAttribute(IntegerAttributeCallback callback) { readTemperatureDisplayModeAttribute(chipClusterPtr, callback); } - public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeTemperatureDisplayModeAttribute( + DefaultClusterCallback callback, Integer value) { writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, null); } - public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeTemperatureDisplayModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeTemperatureDisplayModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeTemperatureDisplayModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readKeypadLockoutAttribute( - IntegerAttributeCallback callback - ) { + public void readKeypadLockoutAttribute(IntegerAttributeCallback callback) { readKeypadLockoutAttribute(chipClusterPtr, callback); } + public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value) { writeKeypadLockoutAttribute(chipClusterPtr, callback, value, null); } - public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeKeypadLockoutAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeKeypadLockoutAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeKeypadLockoutAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeKeypadLockoutAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readScheduleProgrammingVisibilityAttribute( - IntegerAttributeCallback callback - ) { + public void readScheduleProgrammingVisibilityAttribute(IntegerAttributeCallback callback) { readScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback); } - public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeScheduleProgrammingVisibilityAttribute( + DefaultClusterCallback callback, Integer value) { writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, null); } - public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeScheduleProgrammingVisibilityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeScheduleProgrammingVisibilityAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeScheduleProgrammingVisibilityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeScheduleProgrammingVisibilityAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { - readClusterRevisionAttribute(chipClusterPtr, callback); + 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 readTemperatureDisplayModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeTemperatureDisplayModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeTemperatureDisplayModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readKeypadLockoutAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeKeypadLockoutAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeKeypadLockoutAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readScheduleProgrammingVisibilityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeScheduleProgrammingVisibilityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeScheduleProgrammingVisibilityAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 53L; + + public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void resetCounts(DefaultClusterCallback callback) { + resetCounts(chipClusterPtr, callback, null); + } + + public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + private native void resetCounts( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface NeighborTableListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + + public interface RouteTableListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void readTemperatureDisplayModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeTemperatureDisplayModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeTemperatureDisplayModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readKeypadLockoutAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeKeypadLockoutAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeKeypadLockoutAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readScheduleProgrammingVisibilityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + public interface SecurityPolicyAttributeCallback { + void onSuccess(List valueList); - public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 53L; + void onError(Exception ex); - public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); + default void onSubscriptionEstablished() {} } - @Override - public native long initWithDevice(long devicePtr, int endpointId); + public interface OperationalDatasetComponentsAttributeCallback { + void onSuccess( + List valueList); - public void resetCounts(DefaultClusterCallback callback - ) { - resetCounts(chipClusterPtr, callback, null); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void resetCounts(DefaultClusterCallback callback + public interface ActiveNetworkFaultsListAttributeCallback { + void onSuccess(List valueList); - , int timedInvokeTimeoutMs) { - resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface NeighborTableListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface RouteTableListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface SecurityPolicyAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface OperationalDatasetComponentsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveNetworkFaultsListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readChannelAttribute( - IntegerAttributeCallback callback - ) { + public void readChannelAttribute(IntegerAttributeCallback callback) { readChannelAttribute(chipClusterPtr, callback); } + public void subscribeChannelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeChannelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRoutingRoleAttribute( - IntegerAttributeCallback callback - ) { + public void readRoutingRoleAttribute(IntegerAttributeCallback callback) { readRoutingRoleAttribute(chipClusterPtr, callback); } + public void subscribeRoutingRoleAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRoutingRoleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNetworkNameAttribute( - CharStringAttributeCallback callback - ) { + public void readNetworkNameAttribute(CharStringAttributeCallback callback) { readNetworkNameAttribute(chipClusterPtr, callback); } + public void subscribeNetworkNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNetworkNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPanIdAttribute( - IntegerAttributeCallback callback - ) { + public void readPanIdAttribute(IntegerAttributeCallback callback) { readPanIdAttribute(chipClusterPtr, callback); } + public void subscribePanIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readExtendedPanIdAttribute( - LongAttributeCallback callback - ) { + public void readExtendedPanIdAttribute(LongAttributeCallback callback) { readExtendedPanIdAttribute(chipClusterPtr, callback); } + public void subscribeExtendedPanIdAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeExtendedPanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMeshLocalPrefixAttribute( - OctetStringAttributeCallback callback - ) { + public void readMeshLocalPrefixAttribute(OctetStringAttributeCallback callback) { readMeshLocalPrefixAttribute(chipClusterPtr, callback); } + public void subscribeMeshLocalPrefixAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeshLocalPrefixAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute( - LongAttributeCallback callback - ) { + public void readOverrunCountAttribute(LongAttributeCallback callback) { readOverrunCountAttribute(chipClusterPtr, callback); } + public void subscribeOverrunCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNeighborTableListAttribute( - NeighborTableListAttributeCallback callback - ) { + public void readNeighborTableListAttribute(NeighborTableListAttributeCallback callback) { readNeighborTableListAttribute(chipClusterPtr, callback); } + public void subscribeNeighborTableListAttribute( - NeighborTableListAttributeCallback callback - , - int minInterval, int maxInterval) { + NeighborTableListAttributeCallback callback, int minInterval, int maxInterval) { subscribeNeighborTableListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRouteTableListAttribute( - RouteTableListAttributeCallback callback - ) { + public void readRouteTableListAttribute(RouteTableListAttributeCallback callback) { readRouteTableListAttribute(chipClusterPtr, callback); } + public void subscribeRouteTableListAttribute( - RouteTableListAttributeCallback callback - , - int minInterval, int maxInterval) { + RouteTableListAttributeCallback callback, int minInterval, int maxInterval) { subscribeRouteTableListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartitionIdAttribute( - LongAttributeCallback callback - ) { + public void readPartitionIdAttribute(LongAttributeCallback callback) { readPartitionIdAttribute(chipClusterPtr, callback); } + public void subscribePartitionIdAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePartitionIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWeightingAttribute( - IntegerAttributeCallback callback - ) { + public void readWeightingAttribute(IntegerAttributeCallback callback) { readWeightingAttribute(chipClusterPtr, callback); } + public void subscribeWeightingAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWeightingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDataVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readDataVersionAttribute(IntegerAttributeCallback callback) { readDataVersionAttribute(chipClusterPtr, callback); } + public void subscribeDataVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStableDataVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readStableDataVersionAttribute(IntegerAttributeCallback callback) { readStableDataVersionAttribute(chipClusterPtr, callback); } + public void subscribeStableDataVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStableDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLeaderRouterIdAttribute( - IntegerAttributeCallback callback - ) { + public void readLeaderRouterIdAttribute(IntegerAttributeCallback callback) { readLeaderRouterIdAttribute(chipClusterPtr, callback); } + public void subscribeLeaderRouterIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLeaderRouterIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDetachedRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readDetachedRoleCountAttribute(IntegerAttributeCallback callback) { readDetachedRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeDetachedRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeDetachedRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readChildRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readChildRoleCountAttribute(IntegerAttributeCallback callback) { readChildRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeChildRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeChildRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRouterRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readRouterRoleCountAttribute(IntegerAttributeCallback callback) { readRouterRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeRouterRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRouterRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLeaderRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readLeaderRoleCountAttribute(IntegerAttributeCallback callback) { readLeaderRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeLeaderRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLeaderRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttachAttemptCountAttribute( - IntegerAttributeCallback callback - ) { + public void readAttachAttemptCountAttribute(IntegerAttributeCallback callback) { readAttachAttemptCountAttribute(chipClusterPtr, callback); } + public void subscribeAttachAttemptCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartitionIdChangeCountAttribute( - IntegerAttributeCallback callback - ) { + public void readPartitionIdChangeCountAttribute(IntegerAttributeCallback callback) { readPartitionIdChangeCountAttribute(chipClusterPtr, callback); } + public void subscribePartitionIdChangeCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePartitionIdChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBetterPartitionAttachAttemptCountAttribute( - IntegerAttributeCallback callback - ) { + public void readBetterPartitionAttachAttemptCountAttribute(IntegerAttributeCallback callback) { readBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback); } + public void subscribeBetterPartitionAttachAttemptCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeBetterPartitionAttachAttemptCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readParentChangeCountAttribute( - IntegerAttributeCallback callback - ) { + public void readParentChangeCountAttribute(IntegerAttributeCallback callback) { readParentChangeCountAttribute(chipClusterPtr, callback); } + public void subscribeParentChangeCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeParentChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxTotalCountAttribute( - LongAttributeCallback callback - ) { + public void readTxTotalCountAttribute(LongAttributeCallback callback) { readTxTotalCountAttribute(chipClusterPtr, callback); } + public void subscribeTxTotalCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxUnicastCountAttribute( - LongAttributeCallback callback - ) { + public void readTxUnicastCountAttribute(LongAttributeCallback callback) { readTxUnicastCountAttribute(chipClusterPtr, callback); } + public void subscribeTxUnicastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBroadcastCountAttribute( - LongAttributeCallback callback - ) { + public void readTxBroadcastCountAttribute(LongAttributeCallback callback) { readTxBroadcastCountAttribute(chipClusterPtr, callback); } + public void subscribeTxBroadcastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxAckRequestedCountAttribute( - LongAttributeCallback callback - ) { + public void readTxAckRequestedCountAttribute(LongAttributeCallback callback) { readTxAckRequestedCountAttribute(chipClusterPtr, callback); } + public void subscribeTxAckRequestedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxAckedCountAttribute( - LongAttributeCallback callback - ) { + public void readTxAckedCountAttribute(LongAttributeCallback callback) { readTxAckedCountAttribute(chipClusterPtr, callback); } + public void subscribeTxAckedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxAckedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxNoAckRequestedCountAttribute( - LongAttributeCallback callback - ) { + public void readTxNoAckRequestedCountAttribute(LongAttributeCallback callback) { readTxNoAckRequestedCountAttribute(chipClusterPtr, callback); } + public void subscribeTxNoAckRequestedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxNoAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDataCountAttribute( - LongAttributeCallback callback - ) { + public void readTxDataCountAttribute(LongAttributeCallback callback) { readTxDataCountAttribute(chipClusterPtr, callback); } + public void subscribeTxDataCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDataPollCountAttribute( - LongAttributeCallback callback - ) { + public void readTxDataPollCountAttribute(LongAttributeCallback callback) { readTxDataPollCountAttribute(chipClusterPtr, callback); } + public void subscribeTxDataPollCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBeaconCountAttribute( - LongAttributeCallback callback - ) { + public void readTxBeaconCountAttribute(LongAttributeCallback callback) { readTxBeaconCountAttribute(chipClusterPtr, callback); } + public void subscribeTxBeaconCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBeaconRequestCountAttribute( - LongAttributeCallback callback - ) { + public void readTxBeaconRequestCountAttribute(LongAttributeCallback callback) { readTxBeaconRequestCountAttribute(chipClusterPtr, callback); } + public void subscribeTxBeaconRequestCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxOtherCountAttribute( - LongAttributeCallback callback - ) { + public void readTxOtherCountAttribute(LongAttributeCallback callback) { readTxOtherCountAttribute(chipClusterPtr, callback); } + public void subscribeTxOtherCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxRetryCountAttribute( - LongAttributeCallback callback - ) { + public void readTxRetryCountAttribute(LongAttributeCallback callback) { readTxRetryCountAttribute(chipClusterPtr, callback); } + public void subscribeTxRetryCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxRetryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback - ) { + public void readTxDirectMaxRetryExpiryCountAttribute(LongAttributeCallback callback) { readTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); } + public void subscribeTxDirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeTxDirectMaxRetryExpiryCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxIndirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback - ) { + public void readTxIndirectMaxRetryExpiryCountAttribute(LongAttributeCallback callback) { readTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); } + public void subscribeTxIndirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeTxIndirectMaxRetryExpiryCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrCcaCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrCcaCountAttribute(LongAttributeCallback callback) { readTxErrCcaCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrCcaCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrCcaCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrAbortCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrAbortCountAttribute(LongAttributeCallback callback) { readTxErrAbortCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrAbortCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrAbortCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrBusyChannelCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrBusyChannelCountAttribute(LongAttributeCallback callback) { readTxErrBusyChannelCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrBusyChannelCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrBusyChannelCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxTotalCountAttribute( - LongAttributeCallback callback - ) { + public void readRxTotalCountAttribute(LongAttributeCallback callback) { readRxTotalCountAttribute(chipClusterPtr, callback); } + public void subscribeRxTotalCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxUnicastCountAttribute( - LongAttributeCallback callback - ) { + public void readRxUnicastCountAttribute(LongAttributeCallback callback) { readRxUnicastCountAttribute(chipClusterPtr, callback); } + public void subscribeRxUnicastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBroadcastCountAttribute( - LongAttributeCallback callback - ) { + public void readRxBroadcastCountAttribute(LongAttributeCallback callback) { readRxBroadcastCountAttribute(chipClusterPtr, callback); } + public void subscribeRxBroadcastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDataCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDataCountAttribute(LongAttributeCallback callback) { readRxDataCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDataCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDataPollCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDataPollCountAttribute(LongAttributeCallback callback) { readRxDataPollCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDataPollCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBeaconCountAttribute( - LongAttributeCallback callback - ) { + public void readRxBeaconCountAttribute(LongAttributeCallback callback) { readRxBeaconCountAttribute(chipClusterPtr, callback); } + public void subscribeRxBeaconCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBeaconRequestCountAttribute( - LongAttributeCallback callback - ) { + public void readRxBeaconRequestCountAttribute(LongAttributeCallback callback) { readRxBeaconRequestCountAttribute(chipClusterPtr, callback); } + public void subscribeRxBeaconRequestCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxOtherCountAttribute( - LongAttributeCallback callback - ) { + public void readRxOtherCountAttribute(LongAttributeCallback callback) { readRxOtherCountAttribute(chipClusterPtr, callback); } + public void subscribeRxOtherCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxAddressFilteredCountAttribute( - LongAttributeCallback callback - ) { + public void readRxAddressFilteredCountAttribute(LongAttributeCallback callback) { readRxAddressFilteredCountAttribute(chipClusterPtr, callback); } + public void subscribeRxAddressFilteredCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxAddressFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDestAddrFilteredCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDestAddrFilteredCountAttribute(LongAttributeCallback callback) { readRxDestAddrFilteredCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDestAddrFilteredCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDestAddrFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDuplicatedCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDuplicatedCountAttribute(LongAttributeCallback callback) { readRxDuplicatedCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDuplicatedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDuplicatedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrNoFrameCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrNoFrameCountAttribute(LongAttributeCallback callback) { readRxErrNoFrameCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrNoFrameCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrNoFrameCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrUnknownNeighborCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrUnknownNeighborCountAttribute(LongAttributeCallback callback) { readRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrUnknownNeighborCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeRxErrUnknownNeighborCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrInvalidSrcAddrCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrInvalidSrcAddrCountAttribute(LongAttributeCallback callback) { readRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrInvalidSrcAddrCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeRxErrInvalidSrcAddrCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrSecCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrSecCountAttribute(LongAttributeCallback callback) { readRxErrSecCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrSecCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrSecCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrFcsCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrFcsCountAttribute(LongAttributeCallback callback) { readRxErrFcsCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrFcsCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrFcsCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrOtherCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrOtherCountAttribute(LongAttributeCallback callback) { readRxErrOtherCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrOtherCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveTimestampAttribute( - LongAttributeCallback callback - ) { + public void readActiveTimestampAttribute(LongAttributeCallback callback) { readActiveTimestampAttribute(chipClusterPtr, callback); } + public void subscribeActiveTimestampAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPendingTimestampAttribute( - LongAttributeCallback callback - ) { + public void readPendingTimestampAttribute(LongAttributeCallback callback) { readPendingTimestampAttribute(chipClusterPtr, callback); } + public void subscribePendingTimestampAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePendingTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDelayAttribute( - LongAttributeCallback callback - ) { + public void readDelayAttribute(LongAttributeCallback callback) { readDelayAttribute(chipClusterPtr, callback); } + public void subscribeDelayAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSecurityPolicyAttribute( - SecurityPolicyAttributeCallback callback - ) { - readSecurityPolicyAttribute(chipClusterPtr, callback); - } - public void subscribeSecurityPolicyAttribute( - SecurityPolicyAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeSecurityPolicyAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + public void readSecurityPolicyAttribute(SecurityPolicyAttributeCallback callback) { + readSecurityPolicyAttribute(chipClusterPtr, callback); + } + + public void subscribeSecurityPolicyAttribute( + SecurityPolicyAttributeCallback callback, int minInterval, int maxInterval) { + subscribeSecurityPolicyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readChannelMaskAttribute(OctetStringAttributeCallback callback) { + readChannelMaskAttribute(chipClusterPtr, callback); + } + + public void subscribeChannelMaskAttribute( + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + subscribeChannelMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOperationalDatasetComponentsAttribute( + OperationalDatasetComponentsAttributeCallback callback) { + readOperationalDatasetComponentsAttribute(chipClusterPtr, callback); + } + + public void subscribeOperationalDatasetComponentsAttribute( + OperationalDatasetComponentsAttributeCallback callback, int minInterval, int maxInterval) { + subscribeOperationalDatasetComponentsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback) { + readActiveNetworkFaultsListAttribute(chipClusterPtr, callback); + } + + public void subscribeActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeActiveNetworkFaultsListAttribute(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 readChannelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeChannelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRoutingRoleAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRoutingRoleAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNetworkNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeNetworkNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPanIdAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePanIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readExtendedPanIdAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeExtendedPanIdAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMeshLocalPrefixAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeMeshLocalPrefixAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNeighborTableListAttribute( + long chipClusterPtr, NeighborTableListAttributeCallback callback); + + private native void subscribeNeighborTableListAttribute( + long chipClusterPtr, + NeighborTableListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readRouteTableListAttribute( + long chipClusterPtr, RouteTableListAttributeCallback callback); + + private native void subscribeRouteTableListAttribute( + long chipClusterPtr, + RouteTableListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPartitionIdAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePartitionIdAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWeightingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeWeightingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStableDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStableDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLeaderRouterIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLeaderRouterIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDetachedRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeDetachedRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readChildRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeChildRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRouterRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRouterRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLeaderRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLeaderRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPartitionIdChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePartitionIdChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBetterPartitionAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBetterPartitionAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readParentChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeParentChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxAckedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxAckedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxNoAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxNoAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxRetryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxRetryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxDirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxDirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxIndirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxIndirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrCcaCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrCcaCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrAbortCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrAbortCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrBusyChannelCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrBusyChannelCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxAddressFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxAddressFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDestAddrFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDestAddrFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDuplicatedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDuplicatedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrNoFrameCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrNoFrameCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrUnknownNeighborCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrUnknownNeighborCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrInvalidSrcAddrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrInvalidSrcAddrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrSecCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrSecCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrFcsCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrFcsCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeActiveTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPendingTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePendingTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDelayAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeDelayAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSecurityPolicyAttribute( + long chipClusterPtr, SecurityPolicyAttributeCallback callback); + + private native void subscribeSecurityPolicyAttribute( + long chipClusterPtr, + SecurityPolicyAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readChannelMaskAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeChannelMaskAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOperationalDatasetComponentsAttribute( + long chipClusterPtr, OperationalDatasetComponentsAttributeCallback callback); - public void readChannelMaskAttribute( - OctetStringAttributeCallback callback - ) { - readChannelMaskAttribute(chipClusterPtr, callback); - } - public void subscribeChannelMaskAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeChannelMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeOperationalDatasetComponentsAttribute( + long chipClusterPtr, + OperationalDatasetComponentsAttributeCallback callback, + int minInterval, + int maxInterval); - public void readOperationalDatasetComponentsAttribute( - OperationalDatasetComponentsAttributeCallback callback - ) { - readOperationalDatasetComponentsAttribute(chipClusterPtr, callback); - } - public void subscribeOperationalDatasetComponentsAttribute( - OperationalDatasetComponentsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeOperationalDatasetComponentsAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readActiveNetworkFaultsListAttribute( + long chipClusterPtr, ActiveNetworkFaultsListAttributeCallback callback); - public void readActiveNetworkFaultsListAttribute( - ActiveNetworkFaultsListAttributeCallback callback - ) { - readActiveNetworkFaultsListAttribute(chipClusterPtr, callback); - } - public void subscribeActiveNetworkFaultsListAttribute( - ActiveNetworkFaultsListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeActiveNetworkFaultsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeActiveNetworkFaultsListAttribute( + long chipClusterPtr, + ActiveNetworkFaultsListAttributeCallback callback, + int minInterval, + int maxInterval); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { - readAttributeListAttribute(chipClusterPtr, callback); - } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readAttributeListAttribute( + long chipClusterPtr, AttributeListAttributeCallback callback); - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { - readFeatureMapAttribute(chipClusterPtr, callback); - } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeAttributeListAttribute( + long chipClusterPtr, + AttributeListAttributeCallback callback, + int minInterval, + int 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 readFeatureMapAttribute( + long chipClusterPtr, LongAttributeCallback callback); - private native void readChannelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeChannelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRoutingRoleAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRoutingRoleAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNetworkNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeNetworkNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPanIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePanIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readExtendedPanIdAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeExtendedPanIdAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMeshLocalPrefixAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeMeshLocalPrefixAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNeighborTableListAttribute(long chipClusterPtr, - NeighborTableListAttributeCallback callback - ); - private native void subscribeNeighborTableListAttribute(long chipClusterPtr, - NeighborTableListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readRouteTableListAttribute(long chipClusterPtr, - RouteTableListAttributeCallback callback - ); - private native void subscribeRouteTableListAttribute(long chipClusterPtr, - RouteTableListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readPartitionIdAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePartitionIdAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWeightingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeWeightingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStableDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStableDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLeaderRouterIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLeaderRouterIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDetachedRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeDetachedRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readChildRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeChildRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRouterRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRouterRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLeaderRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLeaderRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPartitionIdChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePartitionIdChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readParentChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeParentChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxAckedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxAckedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxNoAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxNoAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxRetryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxRetryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrCcaCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrCcaCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrAbortCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrAbortCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrBusyChannelCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrBusyChannelCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxAddressFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxAddressFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDestAddrFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDestAddrFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDuplicatedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDuplicatedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrNoFrameCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrNoFrameCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrUnknownNeighborCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrUnknownNeighborCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrSecCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrSecCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrFcsCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrFcsCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeActiveTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPendingTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePendingTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDelayAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeDelayAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSecurityPolicyAttribute(long chipClusterPtr, - SecurityPolicyAttributeCallback callback - ); - private native void subscribeSecurityPolicyAttribute(long chipClusterPtr, - SecurityPolicyAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readChannelMaskAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeChannelMaskAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOperationalDatasetComponentsAttribute(long chipClusterPtr, - OperationalDatasetComponentsAttributeCallback callback - ); - private native void subscribeOperationalDatasetComponentsAttribute(long chipClusterPtr, - OperationalDatasetComponentsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readActiveNetworkFaultsListAttribute(long chipClusterPtr, - ActiveNetworkFaultsListAttributeCallback callback - ); - private native void subscribeActiveNetworkFaultsListAttribute(long chipClusterPtr, - ActiveNetworkFaultsListAttributeCallback 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); + 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 TimeFormatLocalizationCluster extends BaseChipCluster { @@ -16223,105 +17276,107 @@ public TimeFormatLocalizationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SupportedCalendarTypesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface SupportedCalendarTypesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readHourFormatAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readHourFormatAttribute(IntegerAttributeCallback callback) { readHourFormatAttribute(chipClusterPtr, callback); } + public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value) { writeHourFormatAttribute(chipClusterPtr, callback, value, null); } - public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeHourFormatAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeHourFormatAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeHourFormatAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeHourFormatAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveCalendarTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readActiveCalendarTypeAttribute(IntegerAttributeCallback callback) { readActiveCalendarTypeAttribute(chipClusterPtr, callback); } + public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value) { writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, null); } - public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeActiveCalendarTypeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeActiveCalendarTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveCalendarTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readSupportedCalendarTypesAttribute( - SupportedCalendarTypesAttributeCallback callback - ) { + SupportedCalendarTypesAttributeCallback callback) { readSupportedCalendarTypesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedCalendarTypesAttribute( - SupportedCalendarTypesAttributeCallback callback - , - int minInterval, int maxInterval) { + SupportedCalendarTypesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedCalendarTypesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readHourFormatAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeHourFormatAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeHourFormatAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveCalendarTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeActiveCalendarTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeActiveCalendarTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedCalendarTypesAttribute(long chipClusterPtr, - SupportedCalendarTypesAttributeCallback callback - ); - private native void subscribeSupportedCalendarTypesAttribute(long chipClusterPtr, - SupportedCalendarTypesAttributeCallback 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); + private native void readHourFormatAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeHourFormatAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeHourFormatAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveCalendarTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeActiveCalendarTypeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeActiveCalendarTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSupportedCalendarTypesAttribute( + long chipClusterPtr, SupportedCalendarTypesAttributeCallback callback); + + private native void subscribeSupportedCalendarTypesAttribute( + long chipClusterPtr, + SupportedCalendarTypesAttributeCallback 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 UnitLocalizationCluster extends BaseChipCluster { @@ -16334,72 +17389,65 @@ public UnitLocalizationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - - public void readTemperatureUnitAttribute( - IntegerAttributeCallback callback - ) { + public void readTemperatureUnitAttribute(IntegerAttributeCallback callback) { readTemperatureUnitAttribute(chipClusterPtr, callback); } + public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value) { writeTemperatureUnitAttribute(chipClusterPtr, callback, value, null); } - public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeTemperatureUnitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeTemperatureUnitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeTemperatureUnitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeTemperatureUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTemperatureUnitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeTemperatureUnitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeTemperatureUnitAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readTemperatureUnitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeTemperatureUnitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeTemperatureUnitAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 UserLabelCluster extends BaseChipCluster { @@ -16412,58 +17460,61 @@ public UserLabelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LabelListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface LabelListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readLabelListAttribute( - LabelListAttributeCallback callback - ) { + public void readLabelListAttribute(LabelListAttributeCallback callback) { readLabelListAttribute(chipClusterPtr, callback); } - public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeLabelListAttribute( + DefaultClusterCallback callback, ArrayList value) { writeLabelListAttribute(chipClusterPtr, callback, value, null); } - public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeLabelListAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeLabelListAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLabelListAttribute( - LabelListAttributeCallback callback - , - int minInterval, int maxInterval) { + LabelListAttributeCallback callback, int minInterval, int maxInterval) { subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback callback - ); + private native void readLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback callback); + + private native void writeLabelListAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); - private native void writeLabelListAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback callback - , int minInterval, int maxInterval); + private native void subscribeLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback 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); + private native void readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class WakeOnLanCluster extends BaseChipCluster { @@ -16476,68 +17527,64 @@ public WakeOnLanCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readWakeOnLanMacAddressAttribute( - CharStringAttributeCallback callback - ) { + public void readWakeOnLanMacAddressAttribute(CharStringAttributeCallback callback) { readWakeOnLanMacAddressAttribute(chipClusterPtr, callback); } + public void subscribeWakeOnLanMacAddressAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeWakeOnLanMacAddressAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readWakeOnLanMacAddressAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeWakeOnLanMacAddressAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readWakeOnLanMacAddressAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeWakeOnLanMacAddressAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class WiFiNetworkDiagnosticsCluster extends BaseChipCluster { @@ -16550,329 +17597,272 @@ public WiFiNetworkDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetCounts(DefaultClusterCallback callback - ) { + public void resetCounts(DefaultClusterCallback callback) { resetCounts(chipClusterPtr, callback, null); } - public void resetCounts(DefaultClusterCallback callback + public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void resetCounts( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readBssidAttribute( - OctetStringAttributeCallback callback - ) { + public void readBssidAttribute(OctetStringAttributeCallback callback) { readBssidAttribute(chipClusterPtr, callback); } + public void subscribeBssidAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeBssidAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSecurityTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readSecurityTypeAttribute(IntegerAttributeCallback callback) { readSecurityTypeAttribute(chipClusterPtr, callback); } + public void subscribeSecurityTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSecurityTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWiFiVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readWiFiVersionAttribute(IntegerAttributeCallback callback) { readWiFiVersionAttribute(chipClusterPtr, callback); } + public void subscribeWiFiVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWiFiVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readChannelNumberAttribute( - IntegerAttributeCallback callback - ) { + public void readChannelNumberAttribute(IntegerAttributeCallback callback) { readChannelNumberAttribute(chipClusterPtr, callback); } + public void subscribeChannelNumberAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeChannelNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRssiAttribute( - IntegerAttributeCallback callback - ) { + public void readRssiAttribute(IntegerAttributeCallback callback) { readRssiAttribute(chipClusterPtr, callback); } + public void subscribeRssiAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRssiAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBeaconLostCountAttribute( - LongAttributeCallback callback - ) { + public void readBeaconLostCountAttribute(LongAttributeCallback callback) { readBeaconLostCountAttribute(chipClusterPtr, callback); } + public void subscribeBeaconLostCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBeaconLostCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBeaconRxCountAttribute( - LongAttributeCallback callback - ) { + public void readBeaconRxCountAttribute(LongAttributeCallback callback) { readBeaconRxCountAttribute(chipClusterPtr, callback); } + public void subscribeBeaconRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBeaconRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketMulticastRxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketMulticastRxCountAttribute(LongAttributeCallback callback) { readPacketMulticastRxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketMulticastRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketMulticastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketMulticastTxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketMulticastTxCountAttribute(LongAttributeCallback callback) { readPacketMulticastTxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketMulticastTxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketMulticastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketUnicastRxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketUnicastRxCountAttribute(LongAttributeCallback callback) { readPacketUnicastRxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketUnicastRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketUnicastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketUnicastTxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketUnicastTxCountAttribute(LongAttributeCallback callback) { readPacketUnicastTxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketUnicastTxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketUnicastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentMaxRateAttribute( - LongAttributeCallback callback - ) { + public void readCurrentMaxRateAttribute(LongAttributeCallback callback) { readCurrentMaxRateAttribute(chipClusterPtr, callback); } + public void subscribeCurrentMaxRateAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentMaxRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute( - LongAttributeCallback callback - ) { + public void readOverrunCountAttribute(LongAttributeCallback callback) { readOverrunCountAttribute(chipClusterPtr, callback); } + public void subscribeOverrunCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBssidAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeBssidAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSecurityTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSecurityTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWiFiVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeWiFiVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readChannelNumberAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeChannelNumberAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRssiAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRssiAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBeaconLostCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBeaconLostCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBeaconRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBeaconRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketMulticastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketMulticastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketMulticastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketMulticastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketUnicastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketUnicastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketUnicastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketUnicastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentMaxRateAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentMaxRateAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readBssidAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeBssidAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSecurityTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSecurityTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWiFiVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeWiFiVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readChannelNumberAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeChannelNumberAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRssiAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRssiAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBeaconLostCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBeaconLostCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBeaconRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBeaconRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketMulticastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketMulticastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketMulticastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketMulticastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketUnicastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketUnicastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketUnicastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketUnicastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentMaxRateAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentMaxRateAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback 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 WindowCoveringCluster extends BaseChipCluster { @@ -16885,556 +17875,581 @@ public WindowCoveringCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void downOrClose(DefaultClusterCallback callback - ) { + public void downOrClose(DefaultClusterCallback callback) { downOrClose(chipClusterPtr, callback, null); } - public void downOrClose(DefaultClusterCallback callback + public void downOrClose(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { downOrClose(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void goToLiftPercentage(DefaultClusterCallback callback - , Integer liftPercentageValue, Integer liftPercent100thsValue) { - goToLiftPercentage(chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, null); + public void goToLiftPercentage( + DefaultClusterCallback callback, + Integer liftPercentageValue, + Integer liftPercent100thsValue) { + goToLiftPercentage( + chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, null); } - public void goToLiftPercentage(DefaultClusterCallback callback - , Integer liftPercentageValue, Integer liftPercent100thsValue - , int timedInvokeTimeoutMs) { - goToLiftPercentage(chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, timedInvokeTimeoutMs); + public void goToLiftPercentage( + DefaultClusterCallback callback, + Integer liftPercentageValue, + Integer liftPercent100thsValue, + int timedInvokeTimeoutMs) { + goToLiftPercentage( + chipClusterPtr, + callback, + liftPercentageValue, + liftPercent100thsValue, + timedInvokeTimeoutMs); } - public void goToLiftValue(DefaultClusterCallback callback - , Integer liftValue) { + public void goToLiftValue(DefaultClusterCallback callback, Integer liftValue) { goToLiftValue(chipClusterPtr, callback, liftValue, null); } - public void goToLiftValue(DefaultClusterCallback callback - , Integer liftValue - , int timedInvokeTimeoutMs) { + public void goToLiftValue( + DefaultClusterCallback callback, Integer liftValue, int timedInvokeTimeoutMs) { goToLiftValue(chipClusterPtr, callback, liftValue, timedInvokeTimeoutMs); } - public void goToTiltPercentage(DefaultClusterCallback callback - , Integer tiltPercentageValue, Integer tiltPercent100thsValue) { - goToTiltPercentage(chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, null); + public void goToTiltPercentage( + DefaultClusterCallback callback, + Integer tiltPercentageValue, + Integer tiltPercent100thsValue) { + goToTiltPercentage( + chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, null); } - public void goToTiltPercentage(DefaultClusterCallback callback - , Integer tiltPercentageValue, Integer tiltPercent100thsValue - , int timedInvokeTimeoutMs) { - goToTiltPercentage(chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, timedInvokeTimeoutMs); + public void goToTiltPercentage( + DefaultClusterCallback callback, + Integer tiltPercentageValue, + Integer tiltPercent100thsValue, + int timedInvokeTimeoutMs) { + goToTiltPercentage( + chipClusterPtr, + callback, + tiltPercentageValue, + tiltPercent100thsValue, + timedInvokeTimeoutMs); } - public void goToTiltValue(DefaultClusterCallback callback - , Integer tiltValue) { + public void goToTiltValue(DefaultClusterCallback callback, Integer tiltValue) { goToTiltValue(chipClusterPtr, callback, tiltValue, null); } - public void goToTiltValue(DefaultClusterCallback callback - , Integer tiltValue - , int timedInvokeTimeoutMs) { + public void goToTiltValue( + DefaultClusterCallback callback, Integer tiltValue, int timedInvokeTimeoutMs) { goToTiltValue(chipClusterPtr, callback, tiltValue, timedInvokeTimeoutMs); } - public void stopMotion(DefaultClusterCallback callback - ) { + public void stopMotion(DefaultClusterCallback callback) { stopMotion(chipClusterPtr, callback, null); } - public void stopMotion(DefaultClusterCallback callback + public void stopMotion(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { stopMotion(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void upOrOpen(DefaultClusterCallback callback - ) { + public void upOrOpen(DefaultClusterCallback callback) { upOrOpen(chipClusterPtr, callback, null); } - public void upOrOpen(DefaultClusterCallback callback + public void upOrOpen(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { upOrOpen(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void downOrClose(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToLiftPercentage(long chipClusterPtr, DefaultClusterCallback Callback - , Integer liftPercentageValue, Integer liftPercent100thsValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToLiftValue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer liftValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToTiltPercentage(long chipClusterPtr, DefaultClusterCallback Callback - , Integer tiltPercentageValue, Integer tiltPercent100thsValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToTiltValue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer tiltValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopMotion(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void upOrOpen(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - - public interface CurrentPositionLiftAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionTiltAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionLiftPercentageAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionTiltPercentageAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface TargetPositionLiftPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface TargetPositionTiltPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionLiftPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionTiltPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readTypeAttribute( - IntegerAttributeCallback callback - ) { + private native void downOrClose( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToLiftPercentage( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer liftPercentageValue, + Integer liftPercent100thsValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToLiftValue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer liftValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToTiltPercentage( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer tiltPercentageValue, + Integer tiltPercent100thsValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToTiltValue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer tiltValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopMotion( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void upOrOpen( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface CurrentPositionLiftAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionTiltAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionLiftPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionTiltPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface TargetPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface TargetPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readTypeAttribute(IntegerAttributeCallback callback) { readTypeAttribute(chipClusterPtr, callback); } + public void subscribeTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionLiftAttribute( - CurrentPositionLiftAttributeCallback callback - ) { + public void readCurrentPositionLiftAttribute(CurrentPositionLiftAttributeCallback callback) { readCurrentPositionLiftAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionLiftAttribute( - CurrentPositionLiftAttributeCallback callback - , - int minInterval, int maxInterval) { + CurrentPositionLiftAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentPositionLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionTiltAttribute( - CurrentPositionTiltAttributeCallback callback - ) { + public void readCurrentPositionTiltAttribute(CurrentPositionTiltAttributeCallback callback) { readCurrentPositionTiltAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionTiltAttribute( - CurrentPositionTiltAttributeCallback callback - , - int minInterval, int maxInterval) { + CurrentPositionTiltAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentPositionTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readConfigStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readConfigStatusAttribute(IntegerAttributeCallback callback) { readConfigStatusAttribute(chipClusterPtr, callback); } + public void subscribeConfigStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeConfigStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionLiftPercentageAttribute( - CurrentPositionLiftPercentageAttributeCallback callback - ) { + CurrentPositionLiftPercentageAttributeCallback callback) { readCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionLiftPercentageAttribute( - CurrentPositionLiftPercentageAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionLiftPercentageAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCurrentPositionLiftPercentageAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionTiltPercentageAttribute( - CurrentPositionTiltPercentageAttributeCallback callback - ) { + CurrentPositionTiltPercentageAttributeCallback callback) { readCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionTiltPercentageAttribute( - CurrentPositionTiltPercentageAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionTiltPercentageAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCurrentPositionTiltPercentageAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperationalStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readOperationalStatusAttribute(IntegerAttributeCallback callback) { readOperationalStatusAttribute(chipClusterPtr, callback); } + public void subscribeOperationalStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOperationalStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTargetPositionLiftPercent100thsAttribute( - TargetPositionLiftPercent100thsAttributeCallback callback - ) { + TargetPositionLiftPercent100thsAttributeCallback callback) { readTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeTargetPositionLiftPercent100thsAttribute( - TargetPositionLiftPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + TargetPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeTargetPositionLiftPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readTargetPositionTiltPercent100thsAttribute( - TargetPositionTiltPercent100thsAttributeCallback callback - ) { + TargetPositionTiltPercent100thsAttributeCallback callback) { readTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeTargetPositionTiltPercent100thsAttribute( - TargetPositionTiltPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + TargetPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeTargetPositionTiltPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readEndProductTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readEndProductTypeAttribute(IntegerAttributeCallback callback) { readEndProductTypeAttribute(chipClusterPtr, callback); } + public void subscribeEndProductTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEndProductTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionLiftPercent100thsAttribute( - CurrentPositionLiftPercent100thsAttributeCallback callback - ) { + CurrentPositionLiftPercent100thsAttributeCallback callback) { readCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionLiftPercent100thsAttribute( - CurrentPositionLiftPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeCurrentPositionLiftPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionTiltPercent100thsAttribute( - CurrentPositionTiltPercent100thsAttributeCallback callback - ) { + CurrentPositionTiltPercent100thsAttributeCallback callback) { readCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionTiltPercent100thsAttribute( - CurrentPositionTiltPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeCurrentPositionTiltPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledOpenLimitLiftAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledOpenLimitLiftAttribute(IntegerAttributeCallback callback) { readInstalledOpenLimitLiftAttribute(chipClusterPtr, callback); } + public void subscribeInstalledOpenLimitLiftAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInstalledOpenLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledClosedLimitLiftAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledClosedLimitLiftAttribute(IntegerAttributeCallback callback) { readInstalledClosedLimitLiftAttribute(chipClusterPtr, callback); } + public void subscribeInstalledClosedLimitLiftAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeInstalledClosedLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeInstalledClosedLimitLiftAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledOpenLimitTiltAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledOpenLimitTiltAttribute(IntegerAttributeCallback callback) { readInstalledOpenLimitTiltAttribute(chipClusterPtr, callback); } + public void subscribeInstalledOpenLimitTiltAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInstalledOpenLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledClosedLimitTiltAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledClosedLimitTiltAttribute(IntegerAttributeCallback callback) { readInstalledClosedLimitTiltAttribute(chipClusterPtr, callback); } + public void subscribeInstalledClosedLimitTiltAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeInstalledClosedLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeInstalledClosedLimitTiltAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readModeAttribute( - IntegerAttributeCallback callback - ) { + public void readModeAttribute(IntegerAttributeCallback callback) { readModeAttribute(chipClusterPtr, callback); } + public void writeModeAttribute(DefaultClusterCallback callback, Integer value) { writeModeAttribute(chipClusterPtr, callback, value, null); } - public void writeModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSafetyStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readSafetyStatusAttribute(IntegerAttributeCallback callback) { readSafetyStatusAttribute(chipClusterPtr, callback); } + public void subscribeSafetyStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftAttribute(long chipClusterPtr, - CurrentPositionLiftAttributeCallback callback - ); - private native void subscribeCurrentPositionLiftAttribute(long chipClusterPtr, - CurrentPositionLiftAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentPositionTiltAttribute(long chipClusterPtr, - CurrentPositionTiltAttributeCallback callback - ); - private native void subscribeCurrentPositionTiltAttribute(long chipClusterPtr, - CurrentPositionTiltAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readConfigStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeConfigStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftPercentageAttribute(long chipClusterPtr, - CurrentPositionLiftPercentageAttributeCallback callback - ); - private native void subscribeCurrentPositionLiftPercentageAttribute(long chipClusterPtr, - CurrentPositionLiftPercentageAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentPositionTiltPercentageAttribute(long chipClusterPtr, - CurrentPositionTiltPercentageAttributeCallback callback - ); - private native void subscribeCurrentPositionTiltPercentageAttribute(long chipClusterPtr, - CurrentPositionTiltPercentageAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOperationalStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOperationalStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, - TargetPositionLiftPercent100thsAttributeCallback callback - ); - private native void subscribeTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, - TargetPositionLiftPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, - TargetPositionTiltPercent100thsAttributeCallback callback - ); - private native void subscribeTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, - TargetPositionTiltPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readEndProductTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEndProductTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, - CurrentPositionLiftPercent100thsAttributeCallback callback - ); - private native void subscribeCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, - CurrentPositionLiftPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, - CurrentPositionTiltPercent100thsAttributeCallback callback - ); - private native void subscribeCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, - CurrentPositionTiltPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readInstalledOpenLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledOpenLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInstalledClosedLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledClosedLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInstalledOpenLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledOpenLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInstalledClosedLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledClosedLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftAttribute( + long chipClusterPtr, CurrentPositionLiftAttributeCallback callback); + + private native void subscribeCurrentPositionLiftAttribute( + long chipClusterPtr, + CurrentPositionLiftAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentPositionTiltAttribute( + long chipClusterPtr, CurrentPositionTiltAttributeCallback callback); + + private native void subscribeCurrentPositionTiltAttribute( + long chipClusterPtr, + CurrentPositionTiltAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readConfigStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeConfigStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercentageAttribute( + long chipClusterPtr, CurrentPositionLiftPercentageAttributeCallback callback); + + private native void subscribeCurrentPositionLiftPercentageAttribute( + long chipClusterPtr, + CurrentPositionLiftPercentageAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentPositionTiltPercentageAttribute( + long chipClusterPtr, CurrentPositionTiltPercentageAttributeCallback callback); + + private native void subscribeCurrentPositionTiltPercentageAttribute( + long chipClusterPtr, + CurrentPositionTiltPercentageAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOperationalStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOperationalStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTargetPositionLiftPercent100thsAttribute( + long chipClusterPtr, TargetPositionLiftPercent100thsAttributeCallback callback); + + private native void subscribeTargetPositionLiftPercent100thsAttribute( + long chipClusterPtr, + TargetPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readTargetPositionTiltPercent100thsAttribute( + long chipClusterPtr, TargetPositionTiltPercent100thsAttributeCallback callback); + + private native void subscribeTargetPositionTiltPercent100thsAttribute( + long chipClusterPtr, + TargetPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEndProductTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEndProductTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercent100thsAttribute( + long chipClusterPtr, CurrentPositionLiftPercent100thsAttributeCallback callback); + + private native void subscribeCurrentPositionLiftPercent100thsAttribute( + long chipClusterPtr, + CurrentPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentPositionTiltPercent100thsAttribute( + long chipClusterPtr, CurrentPositionTiltPercent100thsAttributeCallback callback); + + private native void subscribeCurrentPositionTiltPercent100thsAttribute( + long chipClusterPtr, + CurrentPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readInstalledOpenLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledOpenLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledClosedLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInstalledOpenLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledOpenLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledClosedLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback 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); } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java index 19853055a448c2..bbbf6488468e15 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java @@ -24,2110 +24,1975 @@ import java.util.Optional; public class ChipStructs { -public static class AccessControlClusterTarget { -public @Nullable Long cluster; -public @Nullable Integer endpoint; -public @Nullable Long deviceType; - - public AccessControlClusterTarget( - @Nullable Long cluster - , @Nullable Integer endpoint - , @Nullable Long deviceType - ) { - this.cluster = cluster; - this.endpoint = endpoint; - this.deviceType = deviceType; + public static class AccessControlClusterTarget { + public @Nullable Long cluster; + public @Nullable Integer endpoint; + public @Nullable Long deviceType; + + public AccessControlClusterTarget( + @Nullable Long cluster, @Nullable Integer endpoint, @Nullable Long deviceType) { + this.cluster = cluster; + this.endpoint = endpoint; + this.deviceType = deviceType; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterTarget {\n"); + output.append("\tcluster: "); + output.append(cluster); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("\tdeviceType: "); + output.append(deviceType); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class AccessControlClusterAccessControlEntry { + public Integer fabricIndex; + public Integer privilege; + public Integer authMode; + public @Nullable ArrayList subjects; + public @Nullable ArrayList targets; + + public AccessControlClusterAccessControlEntry( + Integer fabricIndex, + Integer privilege, + Integer authMode, + @Nullable ArrayList subjects, + @Nullable ArrayList targets) { + this.fabricIndex = fabricIndex; + this.privilege = privilege; + this.authMode = authMode; + this.subjects = subjects; + this.targets = targets; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterAccessControlEntry {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tprivilege: "); + output.append(privilege); + output.append("\n"); + output.append("\tauthMode: "); + output.append(authMode); + output.append("\n"); + output.append("\tsubjects: "); + output.append(subjects); + output.append("\n"); + output.append("\ttargets: "); + output.append(targets); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class AccessControlClusterExtensionEntry { + public Integer fabricIndex; + public byte[] data; + + public AccessControlClusterExtensionEntry(Integer fabricIndex, byte[] data) { + this.fabricIndex = fabricIndex; + this.data = data; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterExtensionEntry {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tdata: "); + output.append(Arrays.toString(data)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ApplicationBasicClusterApplicationBasicApplication { + public Integer catalogVendorId; + public String applicationId; + + public ApplicationBasicClusterApplicationBasicApplication( + Integer catalogVendorId, String applicationId) { + this.catalogVendorId = catalogVendorId; + this.applicationId = applicationId; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationBasicClusterApplicationBasicApplication {\n"); + output.append("\tcatalogVendorId: "); + output.append(catalogVendorId); + output.append("\n"); + output.append("\tapplicationId: "); + output.append(applicationId); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ApplicationLauncherClusterApplicationLauncherApplication { + public Integer catalogVendorId; + public String applicationId; + + public ApplicationLauncherClusterApplicationLauncherApplication( + Integer catalogVendorId, String applicationId) { + this.catalogVendorId = catalogVendorId; + this.applicationId = applicationId; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationLauncherClusterApplicationLauncherApplication {\n"); + output.append("\tcatalogVendorId: "); + output.append(catalogVendorId); + output.append("\n"); + output.append("\tapplicationId: "); + output.append(applicationId); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ApplicationLauncherClusterApplicationEP { + public ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application; + public String endpoint; + + public ApplicationLauncherClusterApplicationEP( + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + String endpoint) { + this.application = application; + this.endpoint = endpoint; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationLauncherClusterApplicationEP {\n"); + output.append("\tapplication: "); + output.append(application); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class AudioOutputClusterOutputInfo { + public Integer index; + public Integer outputType; + public String name; + + public AudioOutputClusterOutputInfo(Integer index, Integer outputType, String name) { + this.index = index; + this.outputType = outputType; + this.name = name; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AudioOutputClusterOutputInfo {\n"); + output.append("\tindex: "); + output.append(index); + output.append("\n"); + output.append("\toutputType: "); + output.append(outputType); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class BridgedActionsClusterActionStruct { + public Integer actionID; + public String name; + public Integer type; + public Integer endpointListID; + public Integer supportedCommands; + public Integer status; + + public BridgedActionsClusterActionStruct( + Integer actionID, + String name, + Integer type, + Integer endpointListID, + Integer supportedCommands, + Integer status) { + this.actionID = actionID; + this.name = name; + this.type = type; + this.endpointListID = endpointListID; + this.supportedCommands = supportedCommands; + this.status = status; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedActionsClusterActionStruct {\n"); + output.append("\tactionID: "); + output.append(actionID); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tendpointListID: "); + output.append(endpointListID); + output.append("\n"); + output.append("\tsupportedCommands: "); + output.append(supportedCommands); + output.append("\n"); + output.append("\tstatus: "); + output.append(status); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class BridgedActionsClusterEndpointListStruct { + public Integer endpointListID; + public String name; + public Integer type; + public ArrayList endpoints; + + public BridgedActionsClusterEndpointListStruct( + Integer endpointListID, String name, Integer type, ArrayList endpoints) { + this.endpointListID = endpointListID; + this.name = name; + this.type = type; + this.endpoints = endpoints; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedActionsClusterEndpointListStruct {\n"); + output.append("\tendpointListID: "); + output.append(endpointListID); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tendpoints: "); + output.append(endpoints); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ChannelClusterChannelInfo { + public Integer majorNumber; + public Integer minorNumber; + public String name; + public String callSign; + public String affiliateCallSign; + + public ChannelClusterChannelInfo( + Integer majorNumber, + Integer minorNumber, + String name, + String callSign, + String affiliateCallSign) { + this.majorNumber = majorNumber; + this.minorNumber = minorNumber; + this.name = name; + this.callSign = callSign; + this.affiliateCallSign = affiliateCallSign; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ChannelClusterChannelInfo {\n"); + output.append("\tmajorNumber: "); + output.append(majorNumber); + output.append("\n"); + output.append("\tminorNumber: "); + output.append(minorNumber); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tcallSign: "); + output.append(callSign); + output.append("\n"); + output.append("\taffiliateCallSign: "); + output.append(affiliateCallSign); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ChannelClusterLineupInfo { + public String operatorName; + public String lineupName; + public String postalCode; + public Integer lineupInfoType; + + public ChannelClusterLineupInfo( + String operatorName, String lineupName, String postalCode, Integer lineupInfoType) { + this.operatorName = operatorName; + this.lineupName = lineupName; + this.postalCode = postalCode; + this.lineupInfoType = lineupInfoType; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ChannelClusterLineupInfo {\n"); + output.append("\toperatorName: "); + output.append(operatorName); + output.append("\n"); + output.append("\tlineupName: "); + output.append(lineupName); + output.append("\n"); + output.append("\tpostalCode: "); + output.append(postalCode); + output.append("\n"); + output.append("\tlineupInfoType: "); + output.append(lineupInfoType); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterDimension { + public Double width; + public Double height; + public Integer metric; + + public ContentLauncherClusterDimension(Double width, Double height, Integer metric) { + this.width = width; + this.height = height; + this.metric = metric; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterDimension {\n"); + output.append("\twidth: "); + output.append(width); + output.append("\n"); + output.append("\theight: "); + output.append(height); + output.append("\n"); + output.append("\tmetric: "); + output.append(metric); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterAdditionalInfo { + public String name; + public String value; + + public ContentLauncherClusterAdditionalInfo(String name, String value) { + this.name = name; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterAdditionalInfo {\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterParameter { + public Integer type; + public String value; + public ArrayList externalIDList; + + public ContentLauncherClusterParameter( + Integer type, + String value, + ArrayList externalIDList) { + this.type = type; + this.value = value; + this.externalIDList = externalIDList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterParameter {\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("\texternalIDList: "); + output.append(externalIDList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterContentSearch { + public ArrayList parameterList; + + public ContentLauncherClusterContentSearch( + ArrayList parameterList) { + this.parameterList = parameterList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterContentSearch {\n"); + output.append("\tparameterList: "); + output.append(parameterList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterStyleInformation { + public String imageUrl; + public String color; + public ChipStructs.ContentLauncherClusterDimension size; + + public ContentLauncherClusterStyleInformation( + String imageUrl, String color, ChipStructs.ContentLauncherClusterDimension size) { + this.imageUrl = imageUrl; + this.color = color; + this.size = size; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterStyleInformation {\n"); + output.append("\timageUrl: "); + output.append(imageUrl); + output.append("\n"); + output.append("\tcolor: "); + output.append(color); + output.append("\n"); + output.append("\tsize: "); + output.append(size); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterBrandingInformation { + public String providerName; + public ChipStructs.ContentLauncherClusterStyleInformation background; + public ChipStructs.ContentLauncherClusterStyleInformation logo; + public ChipStructs.ContentLauncherClusterStyleInformation progressBar; + public ChipStructs.ContentLauncherClusterStyleInformation splash; + public ChipStructs.ContentLauncherClusterStyleInformation waterMark; + + public ContentLauncherClusterBrandingInformation( + String providerName, + ChipStructs.ContentLauncherClusterStyleInformation background, + ChipStructs.ContentLauncherClusterStyleInformation logo, + ChipStructs.ContentLauncherClusterStyleInformation progressBar, + ChipStructs.ContentLauncherClusterStyleInformation splash, + ChipStructs.ContentLauncherClusterStyleInformation waterMark) { + this.providerName = providerName; + this.background = background; + this.logo = logo; + this.progressBar = progressBar; + this.splash = splash; + this.waterMark = waterMark; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterBrandingInformation {\n"); + output.append("\tproviderName: "); + output.append(providerName); + output.append("\n"); + output.append("\tbackground: "); + output.append(background); + output.append("\n"); + output.append("\tlogo: "); + output.append(logo); + output.append("\n"); + output.append("\tprogressBar: "); + output.append(progressBar); + output.append("\n"); + output.append("\tsplash: "); + output.append(splash); + output.append("\n"); + output.append("\twaterMark: "); + output.append(waterMark); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class DescriptorClusterDeviceType { + public Long type; + public Integer revision; + + public DescriptorClusterDeviceType(Long type, Integer revision) { + this.type = type; + this.revision = revision; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DescriptorClusterDeviceType {\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\trevision: "); + output.append(revision); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class DoorLockClusterDlCredential { + public Integer credentialType; + public Integer credentialIndex; + + public DoorLockClusterDlCredential(Integer credentialType, Integer credentialIndex) { + this.credentialType = credentialType; + this.credentialIndex = credentialIndex; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DoorLockClusterDlCredential {\n"); + output.append("\tcredentialType: "); + output.append(credentialType); + output.append("\n"); + output.append("\tcredentialIndex: "); + output.append(credentialIndex); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class FixedLabelClusterLabelStruct { + public String label; + public String value; + + public FixedLabelClusterLabelStruct(String label, String value) { + this.label = label; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("FixedLabelClusterLabelStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GeneralCommissioningClusterBasicCommissioningInfoType { + public Long failSafeExpiryLengthMs; + + public GeneralCommissioningClusterBasicCommissioningInfoType(Long failSafeExpiryLengthMs) { + this.failSafeExpiryLengthMs = failSafeExpiryLengthMs; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GeneralCommissioningClusterBasicCommissioningInfoType {\n"); + output.append("\tfailSafeExpiryLengthMs: "); + output.append(failSafeExpiryLengthMs); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GeneralDiagnosticsClusterNetworkInterfaceType { + public String name; + public Boolean fabricConnected; + public Boolean offPremiseServicesReachableIPv4; + public Boolean offPremiseServicesReachableIPv6; + public byte[] hardwareAddress; + public Integer type; + + public GeneralDiagnosticsClusterNetworkInterfaceType( + String name, + Boolean fabricConnected, + Boolean offPremiseServicesReachableIPv4, + Boolean offPremiseServicesReachableIPv6, + byte[] hardwareAddress, + Integer type) { + this.name = name; + this.fabricConnected = fabricConnected; + this.offPremiseServicesReachableIPv4 = offPremiseServicesReachableIPv4; + this.offPremiseServicesReachableIPv6 = offPremiseServicesReachableIPv6; + this.hardwareAddress = hardwareAddress; + this.type = type; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GeneralDiagnosticsClusterNetworkInterfaceType {\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tfabricConnected: "); + output.append(fabricConnected); + output.append("\n"); + output.append("\toffPremiseServicesReachableIPv4: "); + output.append(offPremiseServicesReachableIPv4); + output.append("\n"); + output.append("\toffPremiseServicesReachableIPv6: "); + output.append(offPremiseServicesReachableIPv6); + output.append("\n"); + output.append("\thardwareAddress: "); + output.append(Arrays.toString(hardwareAddress)); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GroupKeyManagementClusterGroupInfo { + public Integer fabricIndex; + public Integer groupId; + public ArrayList endpoints; + public String groupName; + + public GroupKeyManagementClusterGroupInfo( + Integer fabricIndex, Integer groupId, ArrayList endpoints, String groupName) { + this.fabricIndex = fabricIndex; + this.groupId = groupId; + this.endpoints = endpoints; + this.groupName = groupName; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupInfo {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tgroupId: "); + output.append(groupId); + output.append("\n"); + output.append("\tendpoints: "); + output.append(endpoints); + output.append("\n"); + output.append("\tgroupName: "); + output.append(groupName); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GroupKeyManagementClusterGroupKey { + public Integer fabricIndex; + public Integer groupId; + public Integer groupKeySetID; + + public GroupKeyManagementClusterGroupKey( + Integer fabricIndex, Integer groupId, Integer groupKeySetID) { + this.fabricIndex = fabricIndex; + this.groupId = groupId; + this.groupKeySetID = groupKeySetID; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupKey {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tgroupId: "); + output.append(groupId); + output.append("\n"); + output.append("\tgroupKeySetID: "); + output.append(groupKeySetID); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GroupKeyManagementClusterGroupKeySet { + public Integer groupKeySetID; + public Integer securityPolicy; + public byte[] epochKey0; + public Long epochStartTime0; + public byte[] epochKey1; + public Long epochStartTime1; + public byte[] epochKey2; + public Long epochStartTime2; + + public GroupKeyManagementClusterGroupKeySet( + Integer groupKeySetID, + Integer securityPolicy, + byte[] epochKey0, + Long epochStartTime0, + byte[] epochKey1, + Long epochStartTime1, + byte[] epochKey2, + Long epochStartTime2) { + this.groupKeySetID = groupKeySetID; + this.securityPolicy = securityPolicy; + this.epochKey0 = epochKey0; + this.epochStartTime0 = epochStartTime0; + this.epochKey1 = epochKey1; + this.epochStartTime1 = epochStartTime1; + this.epochKey2 = epochKey2; + this.epochStartTime2 = epochStartTime2; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupKeySet {\n"); + output.append("\tgroupKeySetID: "); + output.append(groupKeySetID); + output.append("\n"); + output.append("\tsecurityPolicy: "); + output.append(securityPolicy); + output.append("\n"); + output.append("\tepochKey0: "); + output.append(Arrays.toString(epochKey0)); + output.append("\n"); + output.append("\tepochStartTime0: "); + output.append(epochStartTime0); + output.append("\n"); + output.append("\tepochKey1: "); + output.append(Arrays.toString(epochKey1)); + output.append("\n"); + output.append("\tepochStartTime1: "); + output.append(epochStartTime1); + output.append("\n"); + output.append("\tepochKey2: "); + output.append(Arrays.toString(epochKey2)); + output.append("\n"); + output.append("\tepochStartTime2: "); + output.append(epochStartTime2); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class MediaInputClusterInputInfo { + public Integer index; + public Integer inputType; + public String name; + public String description; + + public MediaInputClusterInputInfo( + Integer index, Integer inputType, String name, String description) { + this.index = index; + this.inputType = inputType; + this.name = name; + this.description = description; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("MediaInputClusterInputInfo {\n"); + output.append("\tindex: "); + output.append(index); + output.append("\n"); + output.append("\tinputType: "); + output.append(inputType); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tdescription: "); + output.append(description); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class MediaPlaybackClusterPlaybackPosition { + public Long updatedAt; + public Long position; + + public MediaPlaybackClusterPlaybackPosition(Long updatedAt, Long position) { + this.updatedAt = updatedAt; + this.position = position; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("MediaPlaybackClusterPlaybackPosition {\n"); + output.append("\tupdatedAt: "); + output.append(updatedAt); + output.append("\n"); + output.append("\tposition: "); + output.append(position); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ModeSelectClusterModeOptionStruct { + public String label; + public Integer mode; + public Long semanticTag; + + public ModeSelectClusterModeOptionStruct(String label, Integer mode, Long semanticTag) { + this.label = label; + this.mode = mode; + this.semanticTag = semanticTag; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ModeSelectClusterModeOptionStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tmode: "); + output.append(mode); + output.append("\n"); + output.append("\tsemanticTag: "); + output.append(semanticTag); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ModeSelectClusterSemanticTag { + public Integer mfgCode; + public Integer value; + + public ModeSelectClusterSemanticTag(Integer mfgCode, Integer value) { + this.mfgCode = mfgCode; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ModeSelectClusterSemanticTag {\n"); + output.append("\tmfgCode: "); + output.append(mfgCode); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class NetworkCommissioningClusterNetworkInfo { + public byte[] networkID; + public Boolean connected; + + public NetworkCommissioningClusterNetworkInfo(byte[] networkID, Boolean connected) { + this.networkID = networkID; + this.connected = connected; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterNetworkInfo {\n"); + output.append("\tnetworkID: "); + output.append(Arrays.toString(networkID)); + output.append("\n"); + output.append("\tconnected: "); + output.append(connected); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class NetworkCommissioningClusterThreadInterfaceScanResult { + public Long panId; + public Long extendedPanId; + public String networkName; + public Integer channel; + public Integer version; + public Long extendedAddress; + public Integer rssi; + public Integer lqi; + + public NetworkCommissioningClusterThreadInterfaceScanResult( + Long panId, + Long extendedPanId, + String networkName, + Integer channel, + Integer version, + Long extendedAddress, + Integer rssi, + Integer lqi) { + this.panId = panId; + this.extendedPanId = extendedPanId; + this.networkName = networkName; + this.channel = channel; + this.version = version; + this.extendedAddress = extendedAddress; + this.rssi = rssi; + this.lqi = lqi; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterThreadInterfaceScanResult {\n"); + output.append("\tpanId: "); + output.append(panId); + output.append("\n"); + output.append("\textendedPanId: "); + output.append(extendedPanId); + output.append("\n"); + output.append("\tnetworkName: "); + output.append(networkName); + output.append("\n"); + output.append("\tchannel: "); + output.append(channel); + output.append("\n"); + output.append("\tversion: "); + output.append(version); + output.append("\n"); + output.append("\textendedAddress: "); + output.append(extendedAddress); + output.append("\n"); + output.append("\trssi: "); + output.append(rssi); + output.append("\n"); + output.append("\tlqi: "); + output.append(lqi); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class NetworkCommissioningClusterWiFiInterfaceScanResult { + public Integer security; + public byte[] ssid; + public byte[] bssid; + public Integer channel; + public Integer wiFiBand; + public Integer rssi; + + public NetworkCommissioningClusterWiFiInterfaceScanResult( + Integer security, + byte[] ssid, + byte[] bssid, + Integer channel, + Integer wiFiBand, + Integer rssi) { + this.security = security; + this.ssid = ssid; + this.bssid = bssid; + this.channel = channel; + this.wiFiBand = wiFiBand; + this.rssi = rssi; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterWiFiInterfaceScanResult {\n"); + output.append("\tsecurity: "); + output.append(security); + output.append("\n"); + output.append("\tssid: "); + output.append(Arrays.toString(ssid)); + output.append("\n"); + output.append("\tbssid: "); + output.append(Arrays.toString(bssid)); + output.append("\n"); + output.append("\tchannel: "); + output.append(channel); + output.append("\n"); + output.append("\twiFiBand: "); + output.append(wiFiBand); + output.append("\n"); + output.append("\trssi: "); + output.append(rssi); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class OtaSoftwareUpdateRequestorClusterProviderLocation { + public Integer fabricIndex; + public Long providerNodeID; + public Integer endpoint; + + public OtaSoftwareUpdateRequestorClusterProviderLocation( + Integer fabricIndex, Long providerNodeID, Integer endpoint) { + this.fabricIndex = fabricIndex; + this.providerNodeID = providerNodeID; + this.endpoint = endpoint; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OtaSoftwareUpdateRequestorClusterProviderLocation {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tproviderNodeID: "); + output.append(providerNodeID); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class OperationalCredentialsClusterFabricDescriptor { + public Integer fabricIndex; + public byte[] rootPublicKey; + public Integer vendorId; + public Long fabricId; + public Long nodeId; + public String label; + + public OperationalCredentialsClusterFabricDescriptor( + Integer fabricIndex, + byte[] rootPublicKey, + Integer vendorId, + Long fabricId, + Long nodeId, + String label) { + this.fabricIndex = fabricIndex; + this.rootPublicKey = rootPublicKey; + this.vendorId = vendorId; + this.fabricId = fabricId; + this.nodeId = nodeId; + this.label = label; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OperationalCredentialsClusterFabricDescriptor {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\trootPublicKey: "); + output.append(Arrays.toString(rootPublicKey)); + output.append("\n"); + output.append("\tvendorId: "); + output.append(vendorId); + output.append("\n"); + output.append("\tfabricId: "); + output.append(fabricId); + output.append("\n"); + output.append("\tnodeId: "); + output.append(nodeId); + output.append("\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class OperationalCredentialsClusterNOCStruct { + public Integer fabricIndex; + public byte[] noc; + public @Nullable byte[] icac; + + public OperationalCredentialsClusterNOCStruct( + Integer fabricIndex, byte[] noc, @Nullable byte[] icac) { + this.fabricIndex = fabricIndex; + this.noc = noc; + this.icac = icac; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OperationalCredentialsClusterNOCStruct {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tnoc: "); + output.append(Arrays.toString(noc)); + output.append("\n"); + output.append("\ticac: "); + output.append(Arrays.toString(icac)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class PowerSourceClusterBatChargeFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterBatChargeFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatChargeFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class PowerSourceClusterBatFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterBatFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class PowerSourceClusterWiredFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterWiredFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterWiredFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ScenesClusterSceneExtensionFieldSet { + public Long clusterId; + public Integer length; + public Integer value; + + public ScenesClusterSceneExtensionFieldSet(Long clusterId, Integer length, Integer value) { + this.clusterId = clusterId; + this.length = length; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ScenesClusterSceneExtensionFieldSet {\n"); + output.append("\tclusterId: "); + output.append(clusterId); + output.append("\n"); + output.append("\tlength: "); + output.append(length); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SoftwareDiagnosticsClusterSoftwareFaultStruct { + public Long id; + public String name; + public byte[] faultRecording; + + public SoftwareDiagnosticsClusterSoftwareFaultStruct( + Long id, String name, byte[] faultRecording) { + this.id = id; + this.name = name; + this.faultRecording = faultRecording; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SoftwareDiagnosticsClusterSoftwareFaultStruct {\n"); + output.append("\tid: "); + output.append(id); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tfaultRecording: "); + output.append(Arrays.toString(faultRecording)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SoftwareDiagnosticsClusterThreadMetrics { + public Long id; + public String name; + public Long stackFreeCurrent; + public Long stackFreeMinimum; + public Long stackSize; + + public SoftwareDiagnosticsClusterThreadMetrics( + Long id, String name, Long stackFreeCurrent, Long stackFreeMinimum, Long stackSize) { + this.id = id; + this.name = name; + this.stackFreeCurrent = stackFreeCurrent; + this.stackFreeMinimum = stackFreeMinimum; + this.stackSize = stackSize; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SoftwareDiagnosticsClusterThreadMetrics {\n"); + output.append("\tid: "); + output.append(id); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tstackFreeCurrent: "); + output.append(stackFreeCurrent); + output.append("\n"); + output.append("\tstackFreeMinimum: "); + output.append(stackFreeMinimum); + output.append("\n"); + output.append("\tstackSize: "); + output.append(stackSize); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TargetNavigatorClusterTargetInfo { + public Integer identifier; + public String name; + + public TargetNavigatorClusterTargetInfo(Integer identifier, String name) { + this.identifier = identifier; + this.name = name; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TargetNavigatorClusterTargetInfo {\n"); + output.append("\tidentifier: "); + output.append(identifier); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterSimpleStruct { + public Integer a; + public Boolean b; + public Integer c; + public byte[] d; + public String e; + public Integer f; + public Float g; + public Double h; + + public TestClusterClusterSimpleStruct( + Integer a, Boolean b, Integer c, byte[] d, String e, Integer f, Float g, Double h) { + this.a = a; + this.b = b; + this.c = c; + this.d = d; + this.e = e; + this.f = f; + this.g = g; + this.h = h; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterSimpleStruct {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("\td: "); + output.append(Arrays.toString(d)); + output.append("\n"); + output.append("\te: "); + output.append(e); + output.append("\n"); + output.append("\tf: "); + output.append(f); + output.append("\n"); + output.append("\tg: "); + output.append(g); + output.append("\n"); + output.append("\th: "); + output.append(h); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterNullablesAndOptionalsStruct { + public @Nullable Integer nullableInt; + public Optional optionalInt; + public @Nullable Optional nullableOptionalInt; + public @Nullable String nullableString; + public Optional optionalString; + public @Nullable Optional nullableOptionalString; + public @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct; + public Optional optionalStruct; + public @Nullable Optional nullableOptionalStruct; + public @Nullable ArrayList nullableList; + public Optional> optionalList; + public @Nullable Optional> nullableOptionalList; + + public TestClusterClusterNullablesAndOptionalsStruct( + @Nullable Integer nullableInt, + Optional optionalInt, + @Nullable Optional nullableOptionalInt, + @Nullable String nullableString, + Optional optionalString, + @Nullable Optional nullableOptionalString, + @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct, + Optional optionalStruct, + @Nullable Optional nullableOptionalStruct, + @Nullable ArrayList nullableList, + Optional> optionalList, + @Nullable Optional> nullableOptionalList) { + this.nullableInt = nullableInt; + this.optionalInt = optionalInt; + this.nullableOptionalInt = nullableOptionalInt; + this.nullableString = nullableString; + this.optionalString = optionalString; + this.nullableOptionalString = nullableOptionalString; + this.nullableStruct = nullableStruct; + this.optionalStruct = optionalStruct; + this.nullableOptionalStruct = nullableOptionalStruct; + this.nullableList = nullableList; + this.optionalList = optionalList; + this.nullableOptionalList = nullableOptionalList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNullablesAndOptionalsStruct {\n"); + output.append("\tnullableInt: "); + output.append(nullableInt); + output.append("\n"); + output.append("\toptionalInt: "); + output.append(optionalInt); + output.append("\n"); + output.append("\tnullableOptionalInt: "); + output.append(nullableOptionalInt); + output.append("\n"); + output.append("\tnullableString: "); + output.append(nullableString); + output.append("\n"); + output.append("\toptionalString: "); + output.append(optionalString); + output.append("\n"); + output.append("\tnullableOptionalString: "); + output.append(nullableOptionalString); + output.append("\n"); + output.append("\tnullableStruct: "); + output.append(nullableStruct); + output.append("\n"); + output.append("\toptionalStruct: "); + output.append(optionalStruct); + output.append("\n"); + output.append("\tnullableOptionalStruct: "); + output.append(nullableOptionalStruct); + output.append("\n"); + output.append("\tnullableList: "); + output.append(nullableList); + output.append("\n"); + output.append("\toptionalList: "); + output.append(optionalList); + output.append("\n"); + output.append("\tnullableOptionalList: "); + output.append(nullableOptionalList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterNestedStruct { + public Integer a; + public Boolean b; + public ChipStructs.TestClusterClusterSimpleStruct c; + + public TestClusterClusterNestedStruct( + Integer a, Boolean b, ChipStructs.TestClusterClusterSimpleStruct c) { + this.a = a; + this.b = b; + this.c = c; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNestedStruct {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterNestedStructList { + public Integer a; + public Boolean b; + public ChipStructs.TestClusterClusterSimpleStruct c; + public ArrayList d; + public ArrayList e; + public ArrayList f; + public ArrayList g; + + public TestClusterClusterNestedStructList( + Integer a, + Boolean b, + ChipStructs.TestClusterClusterSimpleStruct c, + ArrayList d, + ArrayList e, + ArrayList f, + ArrayList g) { + this.a = a; + this.b = b; + this.c = c; + this.d = d; + this.e = e; + this.f = f; + this.g = g; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNestedStructList {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("\td: "); + output.append(d); + output.append("\n"); + output.append("\te: "); + output.append(e); + output.append("\n"); + output.append("\tf: "); + output.append(f); + output.append("\n"); + output.append("\tg: "); + output.append(g); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterDoubleNestedStructList { + public ArrayList a; + + public TestClusterClusterDoubleNestedStructList( + ArrayList a) { + this.a = a; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterDoubleNestedStructList {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterTestFabricScoped { + public Integer fabricIndex; + + public TestClusterClusterTestFabricScoped(Integer fabricIndex) { + this.fabricIndex = fabricIndex; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterTestFabricScoped {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterTestListStructOctet { + public Long fabricIndex; + public byte[] operationalCert; + + public TestClusterClusterTestListStructOctet(Long fabricIndex, byte[] operationalCert) { + this.fabricIndex = fabricIndex; + this.operationalCert = operationalCert; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterTestListStructOctet {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\toperationalCert: "); + output.append(Arrays.toString(operationalCert)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterNeighborTable { + public Long extAddress; + public Long age; + public Integer rloc16; + public Long linkFrameCounter; + public Long mleFrameCounter; + public Integer lqi; + public Integer averageRssi; + public Integer lastRssi; + public Integer frameErrorRate; + public Integer messageErrorRate; + public Boolean rxOnWhenIdle; + public Boolean fullThreadDevice; + public Boolean fullNetworkData; + public Boolean isChild; + + public ThreadNetworkDiagnosticsClusterNeighborTable( + Long extAddress, + Long age, + Integer rloc16, + Long linkFrameCounter, + Long mleFrameCounter, + Integer lqi, + Integer averageRssi, + Integer lastRssi, + Integer frameErrorRate, + Integer messageErrorRate, + Boolean rxOnWhenIdle, + Boolean fullThreadDevice, + Boolean fullNetworkData, + Boolean isChild) { + this.extAddress = extAddress; + this.age = age; + this.rloc16 = rloc16; + this.linkFrameCounter = linkFrameCounter; + this.mleFrameCounter = mleFrameCounter; + this.lqi = lqi; + this.averageRssi = averageRssi; + this.lastRssi = lastRssi; + this.frameErrorRate = frameErrorRate; + this.messageErrorRate = messageErrorRate; + this.rxOnWhenIdle = rxOnWhenIdle; + this.fullThreadDevice = fullThreadDevice; + this.fullNetworkData = fullNetworkData; + this.isChild = isChild; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterNeighborTable {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\tage: "); + output.append(age); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\tlinkFrameCounter: "); + output.append(linkFrameCounter); + output.append("\n"); + output.append("\tmleFrameCounter: "); + output.append(mleFrameCounter); + output.append("\n"); + output.append("\tlqi: "); + output.append(lqi); + output.append("\n"); + output.append("\taverageRssi: "); + output.append(averageRssi); + output.append("\n"); + output.append("\tlastRssi: "); + output.append(lastRssi); + output.append("\n"); + output.append("\tframeErrorRate: "); + output.append(frameErrorRate); + output.append("\n"); + output.append("\tmessageErrorRate: "); + output.append(messageErrorRate); + output.append("\n"); + output.append("\trxOnWhenIdle: "); + output.append(rxOnWhenIdle); + output.append("\n"); + output.append("\tfullThreadDevice: "); + output.append(fullThreadDevice); + output.append("\n"); + output.append("\tfullNetworkData: "); + output.append(fullNetworkData); + output.append("\n"); + output.append("\tisChild: "); + output.append(isChild); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterOperationalDatasetComponents { + public Boolean activeTimestampPresent; + public Boolean pendingTimestampPresent; + public Boolean masterKeyPresent; + public Boolean networkNamePresent; + public Boolean extendedPanIdPresent; + public Boolean meshLocalPrefixPresent; + public Boolean delayPresent; + public Boolean panIdPresent; + public Boolean channelPresent; + public Boolean pskcPresent; + public Boolean securityPolicyPresent; + public Boolean channelMaskPresent; + + public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents( + Boolean activeTimestampPresent, + Boolean pendingTimestampPresent, + Boolean masterKeyPresent, + Boolean networkNamePresent, + Boolean extendedPanIdPresent, + Boolean meshLocalPrefixPresent, + Boolean delayPresent, + Boolean panIdPresent, + Boolean channelPresent, + Boolean pskcPresent, + Boolean securityPolicyPresent, + Boolean channelMaskPresent) { + this.activeTimestampPresent = activeTimestampPresent; + this.pendingTimestampPresent = pendingTimestampPresent; + this.masterKeyPresent = masterKeyPresent; + this.networkNamePresent = networkNamePresent; + this.extendedPanIdPresent = extendedPanIdPresent; + this.meshLocalPrefixPresent = meshLocalPrefixPresent; + this.delayPresent = delayPresent; + this.panIdPresent = panIdPresent; + this.channelPresent = channelPresent; + this.pskcPresent = pskcPresent; + this.securityPolicyPresent = securityPolicyPresent; + this.channelMaskPresent = channelMaskPresent; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterOperationalDatasetComponents {\n"); + output.append("\tactiveTimestampPresent: "); + output.append(activeTimestampPresent); + output.append("\n"); + output.append("\tpendingTimestampPresent: "); + output.append(pendingTimestampPresent); + output.append("\n"); + output.append("\tmasterKeyPresent: "); + output.append(masterKeyPresent); + output.append("\n"); + output.append("\tnetworkNamePresent: "); + output.append(networkNamePresent); + output.append("\n"); + output.append("\textendedPanIdPresent: "); + output.append(extendedPanIdPresent); + output.append("\n"); + output.append("\tmeshLocalPrefixPresent: "); + output.append(meshLocalPrefixPresent); + output.append("\n"); + output.append("\tdelayPresent: "); + output.append(delayPresent); + output.append("\n"); + output.append("\tpanIdPresent: "); + output.append(panIdPresent); + output.append("\n"); + output.append("\tchannelPresent: "); + output.append(channelPresent); + output.append("\n"); + output.append("\tpskcPresent: "); + output.append(pskcPresent); + output.append("\n"); + output.append("\tsecurityPolicyPresent: "); + output.append(securityPolicyPresent); + output.append("\n"); + output.append("\tchannelMaskPresent: "); + output.append(channelMaskPresent); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterRouteTable { + public Long extAddress; + public Integer rloc16; + public Integer routerId; + public Integer nextHop; + public Integer pathCost; + public Integer LQIIn; + public Integer LQIOut; + public Integer age; + public Boolean allocated; + public Boolean linkEstablished; + + public ThreadNetworkDiagnosticsClusterRouteTable( + Long extAddress, + Integer rloc16, + Integer routerId, + Integer nextHop, + Integer pathCost, + Integer LQIIn, + Integer LQIOut, + Integer age, + Boolean allocated, + Boolean linkEstablished) { + this.extAddress = extAddress; + this.rloc16 = rloc16; + this.routerId = routerId; + this.nextHop = nextHop; + this.pathCost = pathCost; + this.LQIIn = LQIIn; + this.LQIOut = LQIOut; + this.age = age; + this.allocated = allocated; + this.linkEstablished = linkEstablished; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterRouteTable {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\trouterId: "); + output.append(routerId); + output.append("\n"); + output.append("\tnextHop: "); + output.append(nextHop); + output.append("\n"); + output.append("\tpathCost: "); + output.append(pathCost); + output.append("\n"); + output.append("\tLQIIn: "); + output.append(LQIIn); + output.append("\n"); + output.append("\tLQIOut: "); + output.append(LQIOut); + output.append("\n"); + output.append("\tage: "); + output.append(age); + output.append("\n"); + output.append("\tallocated: "); + output.append(allocated); + output.append("\n"); + output.append("\tlinkEstablished: "); + output.append(linkEstablished); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterSecurityPolicy { + public Integer rotationTime; + public Integer flags; + + public ThreadNetworkDiagnosticsClusterSecurityPolicy(Integer rotationTime, Integer flags) { + this.rotationTime = rotationTime; + this.flags = flags; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterSecurityPolicy {\n"); + output.append("\trotationTime: "); + output.append(rotationTime); + output.append("\n"); + output.append("\tflags: "); + output.append(flags); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class UserLabelClusterLabelStruct { + public String label; + public String value; + + public UserLabelClusterLabelStruct(String label, String value) { + this.label = label; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("UserLabelClusterLabelStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterTarget {\n"); - output.append("\tcluster: "); - output.append(cluster); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("\tdeviceType: "); - output.append(deviceType); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class AccessControlClusterAccessControlEntry { -public Integer fabricIndex; -public Integer privilege; -public Integer authMode; -public @Nullable ArrayList subjects; -public @Nullable ArrayList targets; - - public AccessControlClusterAccessControlEntry( - Integer fabricIndex - , Integer privilege - , Integer authMode - , @Nullable ArrayList subjects - , @Nullable ArrayList targets - ) { - this.fabricIndex = fabricIndex; - this.privilege = privilege; - this.authMode = authMode; - this.subjects = subjects; - this.targets = targets; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterAccessControlEntry {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tprivilege: "); - output.append(privilege); - output.append("\n"); - output.append("\tauthMode: "); - output.append(authMode); - output.append("\n"); - output.append("\tsubjects: "); - output.append(subjects); - output.append("\n"); - output.append("\ttargets: "); - output.append(targets); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class AccessControlClusterExtensionEntry { -public Integer fabricIndex; -public byte[] data; - - public AccessControlClusterExtensionEntry( - Integer fabricIndex - , byte[] data - ) { - this.fabricIndex = fabricIndex; - this.data = data; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterExtensionEntry {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tdata: "); - output.append(Arrays.toString(data)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ApplicationBasicClusterApplicationBasicApplication { -public Integer catalogVendorId; -public String applicationId; - - public ApplicationBasicClusterApplicationBasicApplication( - Integer catalogVendorId - , String applicationId - ) { - this.catalogVendorId = catalogVendorId; - this.applicationId = applicationId; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationBasicClusterApplicationBasicApplication {\n"); - output.append("\tcatalogVendorId: "); - output.append(catalogVendorId); - output.append("\n"); - output.append("\tapplicationId: "); - output.append(applicationId); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ApplicationLauncherClusterApplicationLauncherApplication { -public Integer catalogVendorId; -public String applicationId; - - public ApplicationLauncherClusterApplicationLauncherApplication( - Integer catalogVendorId - , String applicationId - ) { - this.catalogVendorId = catalogVendorId; - this.applicationId = applicationId; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationLauncherClusterApplicationLauncherApplication {\n"); - output.append("\tcatalogVendorId: "); - output.append(catalogVendorId); - output.append("\n"); - output.append("\tapplicationId: "); - output.append(applicationId); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ApplicationLauncherClusterApplicationEP { -public ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application; -public String endpoint; - - public ApplicationLauncherClusterApplicationEP( - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , String endpoint - ) { - this.application = application; - this.endpoint = endpoint; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationLauncherClusterApplicationEP {\n"); - output.append("\tapplication: "); - output.append(application); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class AudioOutputClusterOutputInfo { -public Integer index; -public Integer outputType; -public String name; - - public AudioOutputClusterOutputInfo( - Integer index - , Integer outputType - , String name - ) { - this.index = index; - this.outputType = outputType; - this.name = name; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AudioOutputClusterOutputInfo {\n"); - output.append("\tindex: "); - output.append(index); - output.append("\n"); - output.append("\toutputType: "); - output.append(outputType); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class BridgedActionsClusterActionStruct { -public Integer actionID; -public String name; -public Integer type; -public Integer endpointListID; -public Integer supportedCommands; -public Integer status; - - public BridgedActionsClusterActionStruct( - Integer actionID - , String name - , Integer type - , Integer endpointListID - , Integer supportedCommands - , Integer status - ) { - this.actionID = actionID; - this.name = name; - this.type = type; - this.endpointListID = endpointListID; - this.supportedCommands = supportedCommands; - this.status = status; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedActionsClusterActionStruct {\n"); - output.append("\tactionID: "); - output.append(actionID); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tendpointListID: "); - output.append(endpointListID); - output.append("\n"); - output.append("\tsupportedCommands: "); - output.append(supportedCommands); - output.append("\n"); - output.append("\tstatus: "); - output.append(status); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class BridgedActionsClusterEndpointListStruct { -public Integer endpointListID; -public String name; -public Integer type; -public ArrayList endpoints; - - public BridgedActionsClusterEndpointListStruct( - Integer endpointListID - , String name - , Integer type - , ArrayList endpoints - ) { - this.endpointListID = endpointListID; - this.name = name; - this.type = type; - this.endpoints = endpoints; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedActionsClusterEndpointListStruct {\n"); - output.append("\tendpointListID: "); - output.append(endpointListID); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tendpoints: "); - output.append(endpoints); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ChannelClusterChannelInfo { -public Integer majorNumber; -public Integer minorNumber; -public String name; -public String callSign; -public String affiliateCallSign; - - public ChannelClusterChannelInfo( - Integer majorNumber - , Integer minorNumber - , String name - , String callSign - , String affiliateCallSign - ) { - this.majorNumber = majorNumber; - this.minorNumber = minorNumber; - this.name = name; - this.callSign = callSign; - this.affiliateCallSign = affiliateCallSign; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ChannelClusterChannelInfo {\n"); - output.append("\tmajorNumber: "); - output.append(majorNumber); - output.append("\n"); - output.append("\tminorNumber: "); - output.append(minorNumber); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tcallSign: "); - output.append(callSign); - output.append("\n"); - output.append("\taffiliateCallSign: "); - output.append(affiliateCallSign); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ChannelClusterLineupInfo { -public String operatorName; -public String lineupName; -public String postalCode; -public Integer lineupInfoType; - - public ChannelClusterLineupInfo( - String operatorName - , String lineupName - , String postalCode - , Integer lineupInfoType - ) { - this.operatorName = operatorName; - this.lineupName = lineupName; - this.postalCode = postalCode; - this.lineupInfoType = lineupInfoType; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ChannelClusterLineupInfo {\n"); - output.append("\toperatorName: "); - output.append(operatorName); - output.append("\n"); - output.append("\tlineupName: "); - output.append(lineupName); - output.append("\n"); - output.append("\tpostalCode: "); - output.append(postalCode); - output.append("\n"); - output.append("\tlineupInfoType: "); - output.append(lineupInfoType); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterDimension { -public Double width; -public Double height; -public Integer metric; - - public ContentLauncherClusterDimension( - Double width - , Double height - , Integer metric - ) { - this.width = width; - this.height = height; - this.metric = metric; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterDimension {\n"); - output.append("\twidth: "); - output.append(width); - output.append("\n"); - output.append("\theight: "); - output.append(height); - output.append("\n"); - output.append("\tmetric: "); - output.append(metric); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterAdditionalInfo { -public String name; -public String value; - - public ContentLauncherClusterAdditionalInfo( - String name - , String value - ) { - this.name = name; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterAdditionalInfo {\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterParameter { -public Integer type; -public String value; -public ArrayList externalIDList; - - public ContentLauncherClusterParameter( - Integer type - , String value - , ArrayList externalIDList - ) { - this.type = type; - this.value = value; - this.externalIDList = externalIDList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterParameter {\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("\texternalIDList: "); - output.append(externalIDList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterContentSearch { -public ArrayList parameterList; - - public ContentLauncherClusterContentSearch( - ArrayList parameterList - ) { - this.parameterList = parameterList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterContentSearch {\n"); - output.append("\tparameterList: "); - output.append(parameterList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterStyleInformation { -public String imageUrl; -public String color; -public ChipStructs.ContentLauncherClusterDimension size; - - public ContentLauncherClusterStyleInformation( - String imageUrl - , String color - , ChipStructs.ContentLauncherClusterDimension size - ) { - this.imageUrl = imageUrl; - this.color = color; - this.size = size; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterStyleInformation {\n"); - output.append("\timageUrl: "); - output.append(imageUrl); - output.append("\n"); - output.append("\tcolor: "); - output.append(color); - output.append("\n"); - output.append("\tsize: "); - output.append(size); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterBrandingInformation { -public String providerName; -public ChipStructs.ContentLauncherClusterStyleInformation background; -public ChipStructs.ContentLauncherClusterStyleInformation logo; -public ChipStructs.ContentLauncherClusterStyleInformation progressBar; -public ChipStructs.ContentLauncherClusterStyleInformation splash; -public ChipStructs.ContentLauncherClusterStyleInformation waterMark; - - public ContentLauncherClusterBrandingInformation( - String providerName - , ChipStructs.ContentLauncherClusterStyleInformation background - , ChipStructs.ContentLauncherClusterStyleInformation logo - , ChipStructs.ContentLauncherClusterStyleInformation progressBar - , ChipStructs.ContentLauncherClusterStyleInformation splash - , ChipStructs.ContentLauncherClusterStyleInformation waterMark - ) { - this.providerName = providerName; - this.background = background; - this.logo = logo; - this.progressBar = progressBar; - this.splash = splash; - this.waterMark = waterMark; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterBrandingInformation {\n"); - output.append("\tproviderName: "); - output.append(providerName); - output.append("\n"); - output.append("\tbackground: "); - output.append(background); - output.append("\n"); - output.append("\tlogo: "); - output.append(logo); - output.append("\n"); - output.append("\tprogressBar: "); - output.append(progressBar); - output.append("\n"); - output.append("\tsplash: "); - output.append(splash); - output.append("\n"); - output.append("\twaterMark: "); - output.append(waterMark); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class DescriptorClusterDeviceType { -public Long type; -public Integer revision; - - public DescriptorClusterDeviceType( - Long type - , Integer revision - ) { - this.type = type; - this.revision = revision; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DescriptorClusterDeviceType {\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\trevision: "); - output.append(revision); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class DoorLockClusterDlCredential { -public Integer credentialType; -public Integer credentialIndex; - - public DoorLockClusterDlCredential( - Integer credentialType - , Integer credentialIndex - ) { - this.credentialType = credentialType; - this.credentialIndex = credentialIndex; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DoorLockClusterDlCredential {\n"); - output.append("\tcredentialType: "); - output.append(credentialType); - output.append("\n"); - output.append("\tcredentialIndex: "); - output.append(credentialIndex); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class FixedLabelClusterLabelStruct { -public String label; -public String value; - - public FixedLabelClusterLabelStruct( - String label - , String value - ) { - this.label = label; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("FixedLabelClusterLabelStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GeneralCommissioningClusterBasicCommissioningInfoType { -public Long failSafeExpiryLengthMs; - - public GeneralCommissioningClusterBasicCommissioningInfoType( - Long failSafeExpiryLengthMs - ) { - this.failSafeExpiryLengthMs = failSafeExpiryLengthMs; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GeneralCommissioningClusterBasicCommissioningInfoType {\n"); - output.append("\tfailSafeExpiryLengthMs: "); - output.append(failSafeExpiryLengthMs); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GeneralDiagnosticsClusterNetworkInterfaceType { -public String name; -public Boolean fabricConnected; -public Boolean offPremiseServicesReachableIPv4; -public Boolean offPremiseServicesReachableIPv6; -public byte[] hardwareAddress; -public Integer type; - - public GeneralDiagnosticsClusterNetworkInterfaceType( - String name - , Boolean fabricConnected - , Boolean offPremiseServicesReachableIPv4 - , Boolean offPremiseServicesReachableIPv6 - , byte[] hardwareAddress - , Integer type - ) { - this.name = name; - this.fabricConnected = fabricConnected; - this.offPremiseServicesReachableIPv4 = offPremiseServicesReachableIPv4; - this.offPremiseServicesReachableIPv6 = offPremiseServicesReachableIPv6; - this.hardwareAddress = hardwareAddress; - this.type = type; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GeneralDiagnosticsClusterNetworkInterfaceType {\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tfabricConnected: "); - output.append(fabricConnected); - output.append("\n"); - output.append("\toffPremiseServicesReachableIPv4: "); - output.append(offPremiseServicesReachableIPv4); - output.append("\n"); - output.append("\toffPremiseServicesReachableIPv6: "); - output.append(offPremiseServicesReachableIPv6); - output.append("\n"); - output.append("\thardwareAddress: "); - output.append(Arrays.toString(hardwareAddress)); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GroupKeyManagementClusterGroupInfo { -public Integer fabricIndex; -public Integer groupId; -public ArrayList endpoints; -public String groupName; - - public GroupKeyManagementClusterGroupInfo( - Integer fabricIndex - , Integer groupId - , ArrayList endpoints - , String groupName - ) { - this.fabricIndex = fabricIndex; - this.groupId = groupId; - this.endpoints = endpoints; - this.groupName = groupName; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupInfo {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tgroupId: "); - output.append(groupId); - output.append("\n"); - output.append("\tendpoints: "); - output.append(endpoints); - output.append("\n"); - output.append("\tgroupName: "); - output.append(groupName); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GroupKeyManagementClusterGroupKey { -public Integer fabricIndex; -public Integer groupId; -public Integer groupKeySetID; - - public GroupKeyManagementClusterGroupKey( - Integer fabricIndex - , Integer groupId - , Integer groupKeySetID - ) { - this.fabricIndex = fabricIndex; - this.groupId = groupId; - this.groupKeySetID = groupKeySetID; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupKey {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tgroupId: "); - output.append(groupId); - output.append("\n"); - output.append("\tgroupKeySetID: "); - output.append(groupKeySetID); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GroupKeyManagementClusterGroupKeySet { -public Integer groupKeySetID; -public Integer securityPolicy; -public byte[] epochKey0; -public Long epochStartTime0; -public byte[] epochKey1; -public Long epochStartTime1; -public byte[] epochKey2; -public Long epochStartTime2; - - public GroupKeyManagementClusterGroupKeySet( - Integer groupKeySetID - , Integer securityPolicy - , byte[] epochKey0 - , Long epochStartTime0 - , byte[] epochKey1 - , Long epochStartTime1 - , byte[] epochKey2 - , Long epochStartTime2 - ) { - this.groupKeySetID = groupKeySetID; - this.securityPolicy = securityPolicy; - this.epochKey0 = epochKey0; - this.epochStartTime0 = epochStartTime0; - this.epochKey1 = epochKey1; - this.epochStartTime1 = epochStartTime1; - this.epochKey2 = epochKey2; - this.epochStartTime2 = epochStartTime2; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupKeySet {\n"); - output.append("\tgroupKeySetID: "); - output.append(groupKeySetID); - output.append("\n"); - output.append("\tsecurityPolicy: "); - output.append(securityPolicy); - output.append("\n"); - output.append("\tepochKey0: "); - output.append(Arrays.toString(epochKey0)); - output.append("\n"); - output.append("\tepochStartTime0: "); - output.append(epochStartTime0); - output.append("\n"); - output.append("\tepochKey1: "); - output.append(Arrays.toString(epochKey1)); - output.append("\n"); - output.append("\tepochStartTime1: "); - output.append(epochStartTime1); - output.append("\n"); - output.append("\tepochKey2: "); - output.append(Arrays.toString(epochKey2)); - output.append("\n"); - output.append("\tepochStartTime2: "); - output.append(epochStartTime2); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class MediaInputClusterInputInfo { -public Integer index; -public Integer inputType; -public String name; -public String description; - - public MediaInputClusterInputInfo( - Integer index - , Integer inputType - , String name - , String description - ) { - this.index = index; - this.inputType = inputType; - this.name = name; - this.description = description; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("MediaInputClusterInputInfo {\n"); - output.append("\tindex: "); - output.append(index); - output.append("\n"); - output.append("\tinputType: "); - output.append(inputType); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tdescription: "); - output.append(description); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class MediaPlaybackClusterPlaybackPosition { -public Long updatedAt; -public Long position; - - public MediaPlaybackClusterPlaybackPosition( - Long updatedAt - , Long position - ) { - this.updatedAt = updatedAt; - this.position = position; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("MediaPlaybackClusterPlaybackPosition {\n"); - output.append("\tupdatedAt: "); - output.append(updatedAt); - output.append("\n"); - output.append("\tposition: "); - output.append(position); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ModeSelectClusterModeOptionStruct { -public String label; -public Integer mode; -public Long semanticTag; - - public ModeSelectClusterModeOptionStruct( - String label - , Integer mode - , Long semanticTag - ) { - this.label = label; - this.mode = mode; - this.semanticTag = semanticTag; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ModeSelectClusterModeOptionStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tmode: "); - output.append(mode); - output.append("\n"); - output.append("\tsemanticTag: "); - output.append(semanticTag); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ModeSelectClusterSemanticTag { -public Integer mfgCode; -public Integer value; - - public ModeSelectClusterSemanticTag( - Integer mfgCode - , Integer value - ) { - this.mfgCode = mfgCode; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ModeSelectClusterSemanticTag {\n"); - output.append("\tmfgCode: "); - output.append(mfgCode); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class NetworkCommissioningClusterNetworkInfo { -public byte[] networkID; -public Boolean connected; - - public NetworkCommissioningClusterNetworkInfo( - byte[] networkID - , Boolean connected - ) { - this.networkID = networkID; - this.connected = connected; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterNetworkInfo {\n"); - output.append("\tnetworkID: "); - output.append(Arrays.toString(networkID)); - output.append("\n"); - output.append("\tconnected: "); - output.append(connected); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class NetworkCommissioningClusterThreadInterfaceScanResult { -public Long panId; -public Long extendedPanId; -public String networkName; -public Integer channel; -public Integer version; -public Long extendedAddress; -public Integer rssi; -public Integer lqi; - - public NetworkCommissioningClusterThreadInterfaceScanResult( - Long panId - , Long extendedPanId - , String networkName - , Integer channel - , Integer version - , Long extendedAddress - , Integer rssi - , Integer lqi - ) { - this.panId = panId; - this.extendedPanId = extendedPanId; - this.networkName = networkName; - this.channel = channel; - this.version = version; - this.extendedAddress = extendedAddress; - this.rssi = rssi; - this.lqi = lqi; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterThreadInterfaceScanResult {\n"); - output.append("\tpanId: "); - output.append(panId); - output.append("\n"); - output.append("\textendedPanId: "); - output.append(extendedPanId); - output.append("\n"); - output.append("\tnetworkName: "); - output.append(networkName); - output.append("\n"); - output.append("\tchannel: "); - output.append(channel); - output.append("\n"); - output.append("\tversion: "); - output.append(version); - output.append("\n"); - output.append("\textendedAddress: "); - output.append(extendedAddress); - output.append("\n"); - output.append("\trssi: "); - output.append(rssi); - output.append("\n"); - output.append("\tlqi: "); - output.append(lqi); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class NetworkCommissioningClusterWiFiInterfaceScanResult { -public Integer security; -public byte[] ssid; -public byte[] bssid; -public Integer channel; -public Integer wiFiBand; -public Integer rssi; - - public NetworkCommissioningClusterWiFiInterfaceScanResult( - Integer security - , byte[] ssid - , byte[] bssid - , Integer channel - , Integer wiFiBand - , Integer rssi - ) { - this.security = security; - this.ssid = ssid; - this.bssid = bssid; - this.channel = channel; - this.wiFiBand = wiFiBand; - this.rssi = rssi; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterWiFiInterfaceScanResult {\n"); - output.append("\tsecurity: "); - output.append(security); - output.append("\n"); - output.append("\tssid: "); - output.append(Arrays.toString(ssid)); - output.append("\n"); - output.append("\tbssid: "); - output.append(Arrays.toString(bssid)); - output.append("\n"); - output.append("\tchannel: "); - output.append(channel); - output.append("\n"); - output.append("\twiFiBand: "); - output.append(wiFiBand); - output.append("\n"); - output.append("\trssi: "); - output.append(rssi); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class OtaSoftwareUpdateRequestorClusterProviderLocation { -public Integer fabricIndex; -public Long providerNodeID; -public Integer endpoint; - - public OtaSoftwareUpdateRequestorClusterProviderLocation( - Integer fabricIndex - , Long providerNodeID - , Integer endpoint - ) { - this.fabricIndex = fabricIndex; - this.providerNodeID = providerNodeID; - this.endpoint = endpoint; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OtaSoftwareUpdateRequestorClusterProviderLocation {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tproviderNodeID: "); - output.append(providerNodeID); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class OperationalCredentialsClusterFabricDescriptor { -public Integer fabricIndex; -public byte[] rootPublicKey; -public Integer vendorId; -public Long fabricId; -public Long nodeId; -public String label; - - public OperationalCredentialsClusterFabricDescriptor( - Integer fabricIndex - , byte[] rootPublicKey - , Integer vendorId - , Long fabricId - , Long nodeId - , String label - ) { - this.fabricIndex = fabricIndex; - this.rootPublicKey = rootPublicKey; - this.vendorId = vendorId; - this.fabricId = fabricId; - this.nodeId = nodeId; - this.label = label; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OperationalCredentialsClusterFabricDescriptor {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\trootPublicKey: "); - output.append(Arrays.toString(rootPublicKey)); - output.append("\n"); - output.append("\tvendorId: "); - output.append(vendorId); - output.append("\n"); - output.append("\tfabricId: "); - output.append(fabricId); - output.append("\n"); - output.append("\tnodeId: "); - output.append(nodeId); - output.append("\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class OperationalCredentialsClusterNOCStruct { -public Integer fabricIndex; -public byte[] noc; -public @Nullable byte[] icac; - - public OperationalCredentialsClusterNOCStruct( - Integer fabricIndex - , byte[] noc - , @Nullable byte[] icac - ) { - this.fabricIndex = fabricIndex; - this.noc = noc; - this.icac = icac; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OperationalCredentialsClusterNOCStruct {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tnoc: "); - output.append(Arrays.toString(noc)); - output.append("\n"); - output.append("\ticac: "); - output.append(Arrays.toString(icac)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class PowerSourceClusterBatChargeFaultChangeType { -public ArrayList current; -public ArrayList previous; - - public PowerSourceClusterBatChargeFaultChangeType( - ArrayList current - , ArrayList previous - ) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterBatChargeFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class PowerSourceClusterBatFaultChangeType { -public ArrayList current; -public ArrayList previous; - - public PowerSourceClusterBatFaultChangeType( - ArrayList current - , ArrayList previous - ) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterBatFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class PowerSourceClusterWiredFaultChangeType { -public ArrayList current; -public ArrayList previous; - - public PowerSourceClusterWiredFaultChangeType( - ArrayList current - , ArrayList previous - ) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterWiredFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ScenesClusterSceneExtensionFieldSet { -public Long clusterId; -public Integer length; -public Integer value; - - public ScenesClusterSceneExtensionFieldSet( - Long clusterId - , Integer length - , Integer value - ) { - this.clusterId = clusterId; - this.length = length; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ScenesClusterSceneExtensionFieldSet {\n"); - output.append("\tclusterId: "); - output.append(clusterId); - output.append("\n"); - output.append("\tlength: "); - output.append(length); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class SoftwareDiagnosticsClusterSoftwareFaultStruct { -public Long id; -public String name; -public byte[] faultRecording; - - public SoftwareDiagnosticsClusterSoftwareFaultStruct( - Long id - , String name - , byte[] faultRecording - ) { - this.id = id; - this.name = name; - this.faultRecording = faultRecording; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SoftwareDiagnosticsClusterSoftwareFaultStruct {\n"); - output.append("\tid: "); - output.append(id); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tfaultRecording: "); - output.append(Arrays.toString(faultRecording)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class SoftwareDiagnosticsClusterThreadMetrics { -public Long id; -public String name; -public Long stackFreeCurrent; -public Long stackFreeMinimum; -public Long stackSize; - - public SoftwareDiagnosticsClusterThreadMetrics( - Long id - , String name - , Long stackFreeCurrent - , Long stackFreeMinimum - , Long stackSize - ) { - this.id = id; - this.name = name; - this.stackFreeCurrent = stackFreeCurrent; - this.stackFreeMinimum = stackFreeMinimum; - this.stackSize = stackSize; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SoftwareDiagnosticsClusterThreadMetrics {\n"); - output.append("\tid: "); - output.append(id); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tstackFreeCurrent: "); - output.append(stackFreeCurrent); - output.append("\n"); - output.append("\tstackFreeMinimum: "); - output.append(stackFreeMinimum); - output.append("\n"); - output.append("\tstackSize: "); - output.append(stackSize); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TargetNavigatorClusterTargetInfo { -public Integer identifier; -public String name; - - public TargetNavigatorClusterTargetInfo( - Integer identifier - , String name - ) { - this.identifier = identifier; - this.name = name; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TargetNavigatorClusterTargetInfo {\n"); - output.append("\tidentifier: "); - output.append(identifier); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterSimpleStruct { -public Integer a; -public Boolean b; -public Integer c; -public byte[] d; -public String e; -public Integer f; -public Float g; -public Double h; - - public TestClusterClusterSimpleStruct( - Integer a - , Boolean b - , Integer c - , byte[] d - , String e - , Integer f - , Float g - , Double h - ) { - this.a = a; - this.b = b; - this.c = c; - this.d = d; - this.e = e; - this.f = f; - this.g = g; - this.h = h; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterSimpleStruct {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("\td: "); - output.append(Arrays.toString(d)); - output.append("\n"); - output.append("\te: "); - output.append(e); - output.append("\n"); - output.append("\tf: "); - output.append(f); - output.append("\n"); - output.append("\tg: "); - output.append(g); - output.append("\n"); - output.append("\th: "); - output.append(h); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterNullablesAndOptionalsStruct { -public @Nullable Integer nullableInt; -public Optional optionalInt; -public @Nullable Optional nullableOptionalInt; -public @Nullable String nullableString; -public Optional optionalString; -public @Nullable Optional nullableOptionalString; -public @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct; -public Optional optionalStruct; -public @Nullable Optional nullableOptionalStruct; -public @Nullable ArrayList nullableList; -public Optional> optionalList; -public @Nullable Optional> nullableOptionalList; - - public TestClusterClusterNullablesAndOptionalsStruct( - @Nullable Integer nullableInt - , Optional optionalInt - , @Nullable Optional nullableOptionalInt - , @Nullable String nullableString - , Optional optionalString - , @Nullable Optional nullableOptionalString - , @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct - , Optional optionalStruct - , @Nullable Optional nullableOptionalStruct - , @Nullable ArrayList nullableList - , Optional> optionalList - , @Nullable Optional> nullableOptionalList - ) { - this.nullableInt = nullableInt; - this.optionalInt = optionalInt; - this.nullableOptionalInt = nullableOptionalInt; - this.nullableString = nullableString; - this.optionalString = optionalString; - this.nullableOptionalString = nullableOptionalString; - this.nullableStruct = nullableStruct; - this.optionalStruct = optionalStruct; - this.nullableOptionalStruct = nullableOptionalStruct; - this.nullableList = nullableList; - this.optionalList = optionalList; - this.nullableOptionalList = nullableOptionalList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNullablesAndOptionalsStruct {\n"); - output.append("\tnullableInt: "); - output.append(nullableInt); - output.append("\n"); - output.append("\toptionalInt: "); - output.append(optionalInt); - output.append("\n"); - output.append("\tnullableOptionalInt: "); - output.append(nullableOptionalInt); - output.append("\n"); - output.append("\tnullableString: "); - output.append(nullableString); - output.append("\n"); - output.append("\toptionalString: "); - output.append(optionalString); - output.append("\n"); - output.append("\tnullableOptionalString: "); - output.append(nullableOptionalString); - output.append("\n"); - output.append("\tnullableStruct: "); - output.append(nullableStruct); - output.append("\n"); - output.append("\toptionalStruct: "); - output.append(optionalStruct); - output.append("\n"); - output.append("\tnullableOptionalStruct: "); - output.append(nullableOptionalStruct); - output.append("\n"); - output.append("\tnullableList: "); - output.append(nullableList); - output.append("\n"); - output.append("\toptionalList: "); - output.append(optionalList); - output.append("\n"); - output.append("\tnullableOptionalList: "); - output.append(nullableOptionalList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterNestedStruct { -public Integer a; -public Boolean b; -public ChipStructs.TestClusterClusterSimpleStruct c; - - public TestClusterClusterNestedStruct( - Integer a - , Boolean b - , ChipStructs.TestClusterClusterSimpleStruct c - ) { - this.a = a; - this.b = b; - this.c = c; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNestedStruct {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterNestedStructList { -public Integer a; -public Boolean b; -public ChipStructs.TestClusterClusterSimpleStruct c; -public ArrayList d; -public ArrayList e; -public ArrayList f; -public ArrayList g; - - public TestClusterClusterNestedStructList( - Integer a - , Boolean b - , ChipStructs.TestClusterClusterSimpleStruct c - , ArrayList d - , ArrayList e - , ArrayList f - , ArrayList g - ) { - this.a = a; - this.b = b; - this.c = c; - this.d = d; - this.e = e; - this.f = f; - this.g = g; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNestedStructList {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("\td: "); - output.append(d); - output.append("\n"); - output.append("\te: "); - output.append(e); - output.append("\n"); - output.append("\tf: "); - output.append(f); - output.append("\n"); - output.append("\tg: "); - output.append(g); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterDoubleNestedStructList { -public ArrayList a; - - public TestClusterClusterDoubleNestedStructList( - ArrayList a - ) { - this.a = a; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterDoubleNestedStructList {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterTestFabricScoped { -public Integer fabricIndex; - - public TestClusterClusterTestFabricScoped( - Integer fabricIndex - ) { - this.fabricIndex = fabricIndex; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterTestFabricScoped {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterTestListStructOctet { -public Long fabricIndex; -public byte[] operationalCert; - - public TestClusterClusterTestListStructOctet( - Long fabricIndex - , byte[] operationalCert - ) { - this.fabricIndex = fabricIndex; - this.operationalCert = operationalCert; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterTestListStructOctet {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\toperationalCert: "); - output.append(Arrays.toString(operationalCert)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterNeighborTable { -public Long extAddress; -public Long age; -public Integer rloc16; -public Long linkFrameCounter; -public Long mleFrameCounter; -public Integer lqi; -public Integer averageRssi; -public Integer lastRssi; -public Integer frameErrorRate; -public Integer messageErrorRate; -public Boolean rxOnWhenIdle; -public Boolean fullThreadDevice; -public Boolean fullNetworkData; -public Boolean isChild; - - public ThreadNetworkDiagnosticsClusterNeighborTable( - Long extAddress - , Long age - , Integer rloc16 - , Long linkFrameCounter - , Long mleFrameCounter - , Integer lqi - , Integer averageRssi - , Integer lastRssi - , Integer frameErrorRate - , Integer messageErrorRate - , Boolean rxOnWhenIdle - , Boolean fullThreadDevice - , Boolean fullNetworkData - , Boolean isChild - ) { - this.extAddress = extAddress; - this.age = age; - this.rloc16 = rloc16; - this.linkFrameCounter = linkFrameCounter; - this.mleFrameCounter = mleFrameCounter; - this.lqi = lqi; - this.averageRssi = averageRssi; - this.lastRssi = lastRssi; - this.frameErrorRate = frameErrorRate; - this.messageErrorRate = messageErrorRate; - this.rxOnWhenIdle = rxOnWhenIdle; - this.fullThreadDevice = fullThreadDevice; - this.fullNetworkData = fullNetworkData; - this.isChild = isChild; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterNeighborTable {\n"); - output.append("\textAddress: "); - output.append(extAddress); - output.append("\n"); - output.append("\tage: "); - output.append(age); - output.append("\n"); - output.append("\trloc16: "); - output.append(rloc16); - output.append("\n"); - output.append("\tlinkFrameCounter: "); - output.append(linkFrameCounter); - output.append("\n"); - output.append("\tmleFrameCounter: "); - output.append(mleFrameCounter); - output.append("\n"); - output.append("\tlqi: "); - output.append(lqi); - output.append("\n"); - output.append("\taverageRssi: "); - output.append(averageRssi); - output.append("\n"); - output.append("\tlastRssi: "); - output.append(lastRssi); - output.append("\n"); - output.append("\tframeErrorRate: "); - output.append(frameErrorRate); - output.append("\n"); - output.append("\tmessageErrorRate: "); - output.append(messageErrorRate); - output.append("\n"); - output.append("\trxOnWhenIdle: "); - output.append(rxOnWhenIdle); - output.append("\n"); - output.append("\tfullThreadDevice: "); - output.append(fullThreadDevice); - output.append("\n"); - output.append("\tfullNetworkData: "); - output.append(fullNetworkData); - output.append("\n"); - output.append("\tisChild: "); - output.append(isChild); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterOperationalDatasetComponents { -public Boolean activeTimestampPresent; -public Boolean pendingTimestampPresent; -public Boolean masterKeyPresent; -public Boolean networkNamePresent; -public Boolean extendedPanIdPresent; -public Boolean meshLocalPrefixPresent; -public Boolean delayPresent; -public Boolean panIdPresent; -public Boolean channelPresent; -public Boolean pskcPresent; -public Boolean securityPolicyPresent; -public Boolean channelMaskPresent; - - public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents( - Boolean activeTimestampPresent - , Boolean pendingTimestampPresent - , Boolean masterKeyPresent - , Boolean networkNamePresent - , Boolean extendedPanIdPresent - , Boolean meshLocalPrefixPresent - , Boolean delayPresent - , Boolean panIdPresent - , Boolean channelPresent - , Boolean pskcPresent - , Boolean securityPolicyPresent - , Boolean channelMaskPresent - ) { - this.activeTimestampPresent = activeTimestampPresent; - this.pendingTimestampPresent = pendingTimestampPresent; - this.masterKeyPresent = masterKeyPresent; - this.networkNamePresent = networkNamePresent; - this.extendedPanIdPresent = extendedPanIdPresent; - this.meshLocalPrefixPresent = meshLocalPrefixPresent; - this.delayPresent = delayPresent; - this.panIdPresent = panIdPresent; - this.channelPresent = channelPresent; - this.pskcPresent = pskcPresent; - this.securityPolicyPresent = securityPolicyPresent; - this.channelMaskPresent = channelMaskPresent; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterOperationalDatasetComponents {\n"); - output.append("\tactiveTimestampPresent: "); - output.append(activeTimestampPresent); - output.append("\n"); - output.append("\tpendingTimestampPresent: "); - output.append(pendingTimestampPresent); - output.append("\n"); - output.append("\tmasterKeyPresent: "); - output.append(masterKeyPresent); - output.append("\n"); - output.append("\tnetworkNamePresent: "); - output.append(networkNamePresent); - output.append("\n"); - output.append("\textendedPanIdPresent: "); - output.append(extendedPanIdPresent); - output.append("\n"); - output.append("\tmeshLocalPrefixPresent: "); - output.append(meshLocalPrefixPresent); - output.append("\n"); - output.append("\tdelayPresent: "); - output.append(delayPresent); - output.append("\n"); - output.append("\tpanIdPresent: "); - output.append(panIdPresent); - output.append("\n"); - output.append("\tchannelPresent: "); - output.append(channelPresent); - output.append("\n"); - output.append("\tpskcPresent: "); - output.append(pskcPresent); - output.append("\n"); - output.append("\tsecurityPolicyPresent: "); - output.append(securityPolicyPresent); - output.append("\n"); - output.append("\tchannelMaskPresent: "); - output.append(channelMaskPresent); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterRouteTable { -public Long extAddress; -public Integer rloc16; -public Integer routerId; -public Integer nextHop; -public Integer pathCost; -public Integer LQIIn; -public Integer LQIOut; -public Integer age; -public Boolean allocated; -public Boolean linkEstablished; - - public ThreadNetworkDiagnosticsClusterRouteTable( - Long extAddress - , Integer rloc16 - , Integer routerId - , Integer nextHop - , Integer pathCost - , Integer LQIIn - , Integer LQIOut - , Integer age - , Boolean allocated - , Boolean linkEstablished - ) { - this.extAddress = extAddress; - this.rloc16 = rloc16; - this.routerId = routerId; - this.nextHop = nextHop; - this.pathCost = pathCost; - this.LQIIn = LQIIn; - this.LQIOut = LQIOut; - this.age = age; - this.allocated = allocated; - this.linkEstablished = linkEstablished; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterRouteTable {\n"); - output.append("\textAddress: "); - output.append(extAddress); - output.append("\n"); - output.append("\trloc16: "); - output.append(rloc16); - output.append("\n"); - output.append("\trouterId: "); - output.append(routerId); - output.append("\n"); - output.append("\tnextHop: "); - output.append(nextHop); - output.append("\n"); - output.append("\tpathCost: "); - output.append(pathCost); - output.append("\n"); - output.append("\tLQIIn: "); - output.append(LQIIn); - output.append("\n"); - output.append("\tLQIOut: "); - output.append(LQIOut); - output.append("\n"); - output.append("\tage: "); - output.append(age); - output.append("\n"); - output.append("\tallocated: "); - output.append(allocated); - output.append("\n"); - output.append("\tlinkEstablished: "); - output.append(linkEstablished); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterSecurityPolicy { -public Integer rotationTime; -public Integer flags; - - public ThreadNetworkDiagnosticsClusterSecurityPolicy( - Integer rotationTime - , Integer flags - ) { - this.rotationTime = rotationTime; - this.flags = flags; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterSecurityPolicy {\n"); - output.append("\trotationTime: "); - output.append(rotationTime); - output.append("\n"); - output.append("\tflags: "); - output.append(flags); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class UserLabelClusterLabelStruct { -public String label; -public String value; - - public UserLabelClusterLabelStruct( - String label - , String value - ) { - this.label = label; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("UserLabelClusterLabelStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index 36b3755afb50ea..8bead24d836255 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -20,26 +20,24 @@ package chip.devicecontroller; import androidx.annotation.Nullable; +import chip.clusterinfo.ClusterCommandCallback; +import chip.clusterinfo.ClusterInfo; +import chip.clusterinfo.CommandParameterInfo; +import chip.clusterinfo.CommandResponseInfo; +import chip.clusterinfo.DelegatedClusterCallback; +import chip.clusterinfo.InteractionInfo; +import chip.devicecontroller.ChipClusters.DefaultClusterCallback; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Optional; -import androidx.annotation.Nullable; -import chip.clusterinfo.ClusterInfo; -import chip.clusterinfo.InteractionInfo; -import chip.clusterinfo.CommandParameterInfo; -import chip.clusterinfo.DelegatedClusterCallback; -import chip.clusterinfo.ClusterCommandCallback; -import chip.clusterinfo.CommandResponseInfo; -import chip.devicecontroller.ChipClusters.DefaultClusterCallback; -import chip.devicecontroller.ClusterReadMapping; -import chip.devicecontroller.ClusterWriteMapping; public class ClusterInfoMapping { - public static class DelegatedCharStringAttributeCallback implements ChipClusters.CharStringAttributeCallback, DelegatedClusterCallback { + public static class DelegatedCharStringAttributeCallback + implements ChipClusters.CharStringAttributeCallback, DelegatedClusterCallback { /** Indicates a successful read for a CHAR_STRING attribute. */ private ClusterCommandCallback callback; @@ -62,7 +60,8 @@ public void onError(Exception error) { } } - public static class DelegatedOctetStringAttributeCallback implements ChipClusters.OctetStringAttributeCallback, DelegatedClusterCallback { + public static class DelegatedOctetStringAttributeCallback + implements ChipClusters.OctetStringAttributeCallback, DelegatedClusterCallback { /** Indicates a successful read for an OCTET_STRING attribute. */ private ClusterCommandCallback callback; @@ -85,7 +84,8 @@ public void onError(Exception error) { } } - public static class DelegatedIntegerAttributeCallback implements ChipClusters.IntegerAttributeCallback, DelegatedClusterCallback { + public static class DelegatedIntegerAttributeCallback + implements ChipClusters.IntegerAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -107,7 +107,8 @@ public void onError(Exception error) { } } - public static class DelegatedLongAttributeCallback implements ChipClusters.LongAttributeCallback, DelegatedClusterCallback { + public static class DelegatedLongAttributeCallback + implements ChipClusters.LongAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -129,7 +130,8 @@ public void onError(Exception error) { } } - public static class DelegatedBooleanAttributeCallback implements ChipClusters.BooleanAttributeCallback, DelegatedClusterCallback { + public static class DelegatedBooleanAttributeCallback + implements ChipClusters.BooleanAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -151,7 +153,8 @@ public void onError(Exception error) { } } - public static class DelegatedFloatAttributeCallback implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { + public static class DelegatedFloatAttributeCallback + implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -173,7 +176,8 @@ public void onError(Exception error) { } } - public static class DelegatedDoubleAttributeCallback implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { + public static class DelegatedDoubleAttributeCallback + implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -195,7 +199,8 @@ public void onError(Exception error) { } } - public static class DelegatedDefaultClusterCallback implements DefaultClusterCallback, DelegatedClusterCallback { + public static class DelegatedDefaultClusterCallback + implements DefaultClusterCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -203,7 +208,8 @@ public void setCallbackDelegate(ClusterCommandCallback callback) { this.callback = callback; } - // Parameters and list-adds here should be generated - refer to the template code that creates each callback interface. + // Parameters and list-adds here should be generated - refer to the template code that creates + // each callback interface. @Override public void onSuccess() { Map responseValues = new LinkedHashMap<>(); @@ -216,7544 +222,8880 @@ public void onError(Exception e) { } } + public static class DelegatedAccessControlClusterAclAttributeCallback + implements ChipClusters.AccessControlCluster.AclAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; - public static class DelegatedAccessControlClusterAclAttributeCallback implements ChipClusters.AccessControlCluster.AclAttributeCallback, 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 DelegatedAccessControlClusterExtensionAttributeCallback implements ChipClusters.AccessControlCluster.ExtensionAttributeCallback, 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 DelegatedAccessControlClusterAttributeListAttributeCallback implements ChipClusters.AccessControlCluster.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 DelegatedGetSetupPINResponseCallback implements ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(String setupPIN) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("setupPIN", "String"); - responseValues.put(setupPINResponseValue, setupPIN); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedAccountLoginClusterAttributeListAttributeCallback implements ChipClusters.AccountLoginCluster.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 DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback implements ChipClusters.AdministratorCommissioningCluster.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 DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback implements ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback, 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 DelegatedApplicationBasicClusterAttributeListAttributeCallback implements ChipClusters.ApplicationBasicCluster.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 DelegatedLauncherResponseCallback implements ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback implements ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback, 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 DelegatedApplicationLauncherClusterAttributeListAttributeCallback implements ChipClusters.ApplicationLauncherCluster.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 DelegatedAudioOutputClusterAudioOutputListAttributeCallback implements ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback, 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 DelegatedAudioOutputClusterAttributeListAttributeCallback implements ChipClusters.AudioOutputCluster.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 DelegatedBarrierControlClusterAttributeListAttributeCallback implements ChipClusters.BarrierControlCluster.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 DelegatedBasicClusterAttributeListAttributeCallback implements ChipClusters.BasicCluster.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 DelegatedBinaryInputBasicClusterAttributeListAttributeCallback implements ChipClusters.BinaryInputBasicCluster.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 DelegatedBindingClusterAttributeListAttributeCallback implements ChipClusters.BindingCluster.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 DelegatedBooleanStateClusterAttributeListAttributeCallback implements ChipClusters.BooleanStateCluster.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 DelegatedBridgedActionsClusterActionListAttributeCallback implements ChipClusters.BridgedActionsCluster.ActionListAttributeCallback, 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 DelegatedBridgedActionsClusterEndpointListAttributeCallback implements ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback, 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 DelegatedBridgedActionsClusterAttributeListAttributeCallback implements ChipClusters.BridgedActionsCluster.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 DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback implements ChipClusters.BridgedDeviceBasicCluster.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 DelegatedChangeChannelResponseCallback implements ChipClusters.ChannelCluster.ChangeChannelResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType) { - Map responseValues = new LinkedHashMap<>(); - // channelMatch: Struct ChannelInfo - // Conversion from this type to Java is not properly implemented yet - CommandResponseInfo errorTypeResponseValue = new CommandResponseInfo("errorType", "Integer"); - responseValues.put(errorTypeResponseValue, errorType); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedChannelClusterChannelListAttributeCallback implements ChipClusters.ChannelCluster.ChannelListAttributeCallback, 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 DelegatedChannelClusterAttributeListAttributeCallback implements ChipClusters.ChannelCluster.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 DelegatedColorControlClusterAttributeListAttributeCallback implements ChipClusters.ColorControlCluster.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 DelegatedLaunchResponseCallback implements ChipClusters.ContentLauncherCluster.LaunchResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback implements ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback, 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 DelegatedContentLauncherClusterAttributeListAttributeCallback implements ChipClusters.ContentLauncherCluster.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 DelegatedDescriptorClusterDeviceListAttributeCallback implements ChipClusters.DescriptorCluster.DeviceListAttributeCallback, 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 DelegatedDescriptorClusterServerListAttributeCallback implements ChipClusters.DescriptorCluster.ServerListAttributeCallback, 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 DelegatedDescriptorClusterClientListAttributeCallback implements ChipClusters.DescriptorCluster.ClientListAttributeCallback, 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 DelegatedDescriptorClusterPartsListAttributeCallback implements ChipClusters.DescriptorCluster.PartsListAttributeCallback, 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 DelegatedDescriptorClusterAttributeListAttributeCallback implements ChipClusters.DescriptorCluster.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 DelegatedRetrieveLogsResponseCallback implements ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo contentResponseValue = new CommandResponseInfo("content", "byte[]"); - responseValues.put(contentResponseValue, content); - CommandResponseInfo timeStampResponseValue = new CommandResponseInfo("timeStamp", "Long"); - responseValues.put(timeStampResponseValue, timeStamp); - CommandResponseInfo timeSinceBootResponseValue = new CommandResponseInfo("timeSinceBoot", "Long"); - responseValues.put(timeSinceBootResponseValue, timeSinceBoot); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedDiagnosticLogsClusterAttributeListAttributeCallback implements ChipClusters.DiagnosticLogsCluster.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 DelegatedGetCredentialStatusResponseCallback implements ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo credentialExistsResponseValue = new CommandResponseInfo("credentialExists", "Boolean"); - responseValues.put(credentialExistsResponseValue, credentialExists); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo nextCredentialIndexResponseValue = new CommandResponseInfo("nextCredentialIndex", "Integer"); - responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetUserResponseCallback implements ChipClusters.DoorLockCluster.GetUserResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo userNameResponseValue = new CommandResponseInfo("userName", "String"); - responseValues.put(userNameResponseValue, userName); - CommandResponseInfo userUniqueIdResponseValue = new CommandResponseInfo("userUniqueId", "Long"); - responseValues.put(userUniqueIdResponseValue, userUniqueId); - CommandResponseInfo userStatusResponseValue = new CommandResponseInfo("userStatus", "Integer"); - responseValues.put(userStatusResponseValue, userStatus); - CommandResponseInfo userTypeResponseValue = new CommandResponseInfo("userType", "Integer"); - responseValues.put(userTypeResponseValue, userType); - CommandResponseInfo credentialRuleResponseValue = new CommandResponseInfo("credentialRule", "Integer"); - responseValues.put(credentialRuleResponseValue, credentialRule); - // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - CommandResponseInfo creatorFabricIndexResponseValue = new CommandResponseInfo("creatorFabricIndex", "Integer"); - responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); - CommandResponseInfo lastModifiedFabricIndexResponseValue = new CommandResponseInfo("lastModifiedFabricIndex", "Integer"); - responseValues.put(lastModifiedFabricIndexResponseValue, lastModifiedFabricIndex); - CommandResponseInfo nextUserIndexResponseValue = new CommandResponseInfo("nextUserIndex", "Integer"); - responseValues.put(nextUserIndexResponseValue, nextUserIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetWeekDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo weekDayIndexResponseValue = new CommandResponseInfo("weekDayIndex", "Integer"); - responseValues.put(weekDayIndexResponseValue, weekDayIndex); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo daysMaskResponseValue = new CommandResponseInfo("daysMask", "Optional"); - responseValues.put(daysMaskResponseValue, daysMask); - CommandResponseInfo startHourResponseValue = new CommandResponseInfo("startHour", "Optional"); - responseValues.put(startHourResponseValue, startHour); - CommandResponseInfo startMinuteResponseValue = new CommandResponseInfo("startMinute", "Optional"); - responseValues.put(startMinuteResponseValue, startMinute); - CommandResponseInfo endHourResponseValue = new CommandResponseInfo("endHour", "Optional"); - responseValues.put(endHourResponseValue, endHour); - CommandResponseInfo endMinuteResponseValue = new CommandResponseInfo("endMinute", "Optional"); - responseValues.put(endMinuteResponseValue, endMinute); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetYearDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo yearDayIndexResponseValue = new CommandResponseInfo("yearDayIndex", "Integer"); - responseValues.put(yearDayIndexResponseValue, yearDayIndex); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo localStartTimeResponseValue = new CommandResponseInfo("localStartTime", "Optional"); - responseValues.put(localStartTimeResponseValue, localStartTime); - CommandResponseInfo localEndTimeResponseValue = new CommandResponseInfo("localEndTime", "Optional"); - responseValues.put(localEndTimeResponseValue, localEndTime); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSetCredentialResponseCallback implements ChipClusters.DoorLockCluster.SetCredentialResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo nextCredentialIndexResponseValue = new CommandResponseInfo("nextCredentialIndex", "Integer"); - responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedDoorLockClusterAttributeListAttributeCallback implements ChipClusters.DoorLockCluster.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 DelegatedElectricalMeasurementClusterAttributeListAttributeCallback implements ChipClusters.ElectricalMeasurementCluster.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 DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.EthernetNetworkDiagnosticsCluster.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 DelegatedFixedLabelClusterLabelListAttributeCallback implements ChipClusters.FixedLabelCluster.LabelListAttributeCallback, 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 DelegatedFixedLabelClusterAttributeListAttributeCallback implements ChipClusters.FixedLabelCluster.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 DelegatedFlowMeasurementClusterAttributeListAttributeCallback implements ChipClusters.FlowMeasurementCluster.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 DelegatedArmFailSafeResponseCallback implements ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedCommissioningCompleteResponseCallback implements ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSetRegulatoryConfigResponseCallback implements ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback implements ChipClusters.GeneralCommissioningCluster.BasicCommissioningInfoListAttributeCallback, 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 DelegatedGeneralCommissioningClusterAttributeListAttributeCallback implements ChipClusters.GeneralCommissioningCluster.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 DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.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 DelegatedKeySetReadAllIndicesResponseCallback implements ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ArrayList groupKeySetIDs) { - Map responseValues = new LinkedHashMap<>(); - // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedKeySetReadResponseCallback implements ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { - Map responseValues = new LinkedHashMap<>(); - // groupKeySet: Struct GroupKeySet - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback implements ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback, 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 DelegatedGroupKeyManagementClusterGroupTableAttributeCallback implements ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback, 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 DelegatedGroupKeyManagementClusterAttributeListAttributeCallback implements ChipClusters.GroupKeyManagementCluster.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 DelegatedAddGroupResponseCallback implements ChipClusters.GroupsCluster.AddGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetGroupMembershipResponseCallback implements ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer capacity, ArrayList groupList) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); - responseValues.put(capacityResponseValue, capacity); - // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveGroupResponseCallback implements ChipClusters.GroupsCluster.RemoveGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedViewGroupResponseCallback implements ChipClusters.GroupsCluster.ViewGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, String groupName) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo groupNameResponseValue = new CommandResponseInfo("groupName", "String"); - responseValues.put(groupNameResponseValue, groupName); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedGroupsClusterAttributeListAttributeCallback implements ChipClusters.GroupsCluster.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 DelegatedIdentifyQueryResponseCallback implements ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer timeout) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo timeoutResponseValue = new CommandResponseInfo("timeout", "Integer"); - responseValues.put(timeoutResponseValue, timeout); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedIdentifyClusterAttributeListAttributeCallback implements ChipClusters.IdentifyCluster.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 DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback implements ChipClusters.IlluminanceMeasurementCluster.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 DelegatedSendKeyResponseCallback implements ChipClusters.KeypadInputCluster.SendKeyResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedKeypadInputClusterAttributeListAttributeCallback implements ChipClusters.KeypadInputCluster.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 DelegatedLevelControlClusterAttributeListAttributeCallback implements ChipClusters.LevelControlCluster.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 DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback implements ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback, 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 DelegatedLowPowerClusterAttributeListAttributeCallback implements ChipClusters.LowPowerCluster.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 DelegatedMediaInputClusterMediaInputListAttributeCallback implements ChipClusters.MediaInputCluster.MediaInputListAttributeCallback, 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 DelegatedMediaInputClusterAttributeListAttributeCallback implements ChipClusters.MediaInputCluster.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 DelegatedPlaybackResponseCallback implements ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedMediaPlaybackClusterAttributeListAttributeCallback implements ChipClusters.MediaPlaybackCluster.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 DelegatedModeSelectClusterSupportedModesAttributeCallback implements ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback, 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 DelegatedModeSelectClusterAttributeListAttributeCallback implements ChipClusters.ModeSelectCluster.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 DelegatedConnectNetworkResponseCallback implements ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText, Long ErrorValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - CommandResponseInfo ErrorValueResponseValue = new CommandResponseInfo("ErrorValue", "Long"); - responseValues.put(ErrorValueResponseValue, ErrorValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNetworkConfigResponseCallback implements ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedScanNetworksResponseCallback implements ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText, Optional> WiFiScanResults, Optional> ThreadScanResults) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - // WiFiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - // ThreadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedNetworkCommissioningClusterNetworksAttributeCallback implements ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback, 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 DelegatedApplyUpdateResponseCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer action, Long delayedActionTime) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo actionResponseValue = new CommandResponseInfo("action", "Integer"); - responseValues.put(actionResponseValue, action); - CommandResponseInfo delayedActionTimeResponseValue = new CommandResponseInfo("delayedActionTime", "Long"); - responseValues.put(delayedActionTimeResponseValue, delayedActionTime); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedQueryImageResponseCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo delayedActionTimeResponseValue = new CommandResponseInfo("delayedActionTime", "Optional"); - responseValues.put(delayedActionTimeResponseValue, delayedActionTime); - CommandResponseInfo imageURIResponseValue = new CommandResponseInfo("imageURI", "Optional"); - responseValues.put(imageURIResponseValue, imageURI); - CommandResponseInfo softwareVersionResponseValue = new CommandResponseInfo("softwareVersion", "Optional"); - responseValues.put(softwareVersionResponseValue, softwareVersion); - CommandResponseInfo softwareVersionStringResponseValue = new CommandResponseInfo("softwareVersionString", "Optional"); - responseValues.put(softwareVersionStringResponseValue, softwareVersionString); - CommandResponseInfo updateTokenResponseValue = new CommandResponseInfo("updateToken", "Optional"); - responseValues.put(updateTokenResponseValue, updateToken); - CommandResponseInfo userConsentNeededResponseValue = new CommandResponseInfo("userConsentNeeded", "Optional"); - responseValues.put(userConsentNeededResponseValue, userConsentNeeded); - CommandResponseInfo metadataForRequestorResponseValue = new CommandResponseInfo("metadataForRequestor", "Optional"); - responseValues.put(metadataForRequestorResponseValue, metadataForRequestor); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.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 DelegatedOtaSoftwareUpdateRequestorClusterDefaultOtaProvidersAttributeCallback implements ChipClusters.OtaSoftwareUpdateRequestorCluster.DefaultOtaProvidersAttributeCallback, 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 DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback implements ChipClusters.OtaSoftwareUpdateRequestorCluster.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 DelegatedOccupancySensingClusterAttributeListAttributeCallback implements ChipClusters.OccupancySensingCluster.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 DelegatedOnOffClusterAttributeListAttributeCallback implements ChipClusters.OnOffCluster.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 DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback implements ChipClusters.OnOffSwitchConfigurationCluster.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 DelegatedAttestationResponseCallback implements ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] AttestationElements, byte[] Signature) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo AttestationElementsResponseValue = new CommandResponseInfo("AttestationElements", "byte[]"); - responseValues.put(AttestationElementsResponseValue, AttestationElements); - CommandResponseInfo SignatureResponseValue = new CommandResponseInfo("Signature", "byte[]"); - responseValues.put(SignatureResponseValue, Signature); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedCertificateChainResponseCallback implements ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] Certificate) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo CertificateResponseValue = new CommandResponseInfo("Certificate", "byte[]"); - responseValues.put(CertificateResponseValue, Certificate); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNOCResponseCallback implements ChipClusters.OperationalCredentialsCluster.NOCResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer StatusCode, Integer FabricIndex, String DebugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo StatusCodeResponseValue = new CommandResponseInfo("StatusCode", "Integer"); - responseValues.put(StatusCodeResponseValue, StatusCode); - CommandResponseInfo FabricIndexResponseValue = new CommandResponseInfo("FabricIndex", "Integer"); - responseValues.put(FabricIndexResponseValue, FabricIndex); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedOpCSRResponseCallback implements ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] NOCSRElements, byte[] AttestationSignature) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NOCSRElementsResponseValue = new CommandResponseInfo("NOCSRElements", "byte[]"); - responseValues.put(NOCSRElementsResponseValue, NOCSRElements); - CommandResponseInfo AttestationSignatureResponseValue = new CommandResponseInfo("AttestationSignature", "byte[]"); - responseValues.put(AttestationSignatureResponseValue, AttestationSignature); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedOperationalCredentialsClusterNOCsAttributeCallback implements ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback, 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 DelegatedOperationalCredentialsClusterFabricsListAttributeCallback implements ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback, 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 DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback implements ChipClusters.OperationalCredentialsCluster.TrustedRootCertificatesAttributeCallback, 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 DelegatedOperationalCredentialsClusterAttributeListAttributeCallback implements ChipClusters.OperationalCredentialsCluster.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 DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback implements ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback, 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 DelegatedPowerSourceClusterAttributeListAttributeCallback implements ChipClusters.PowerSourceCluster.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 DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback implements ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback, 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 DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback implements ChipClusters.PowerSourceConfigurationCluster.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 DelegatedPressureMeasurementClusterAttributeListAttributeCallback implements ChipClusters.PressureMeasurementCluster.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 DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback implements ChipClusters.PumpConfigurationAndControlCluster.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 DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback implements ChipClusters.RelativeHumidityMeasurementCluster.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 DelegatedAddSceneResponseCallback implements ChipClusters.ScenesCluster.AddSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetSceneMembershipResponseCallback implements ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); - responseValues.put(capacityResponseValue, capacity); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneCountResponseValue = new CommandResponseInfo("sceneCount", "Integer"); - responseValues.put(sceneCountResponseValue, sceneCount); - // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveAllScenesResponseCallback implements ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveSceneResponseCallback implements ChipClusters.ScenesCluster.RemoveSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedStoreSceneResponseCallback implements ChipClusters.ScenesCluster.StoreSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedViewSceneResponseCallback implements ChipClusters.ScenesCluster.ViewSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - CommandResponseInfo transitionTimeResponseValue = new CommandResponseInfo("transitionTime", "Integer"); - responseValues.put(transitionTimeResponseValue, transitionTime); - CommandResponseInfo sceneNameResponseValue = new CommandResponseInfo("sceneName", "String"); - responseValues.put(sceneNameResponseValue, sceneName); - // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedScenesClusterAttributeListAttributeCallback implements ChipClusters.ScenesCluster.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 DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback implements ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback, 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 DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.SoftwareDiagnosticsCluster.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 DelegatedSwitchClusterAttributeListAttributeCallback implements ChipClusters.SwitchCluster.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 DelegatedNavigateTargetResponseCallback implements ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback implements ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback, 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 DelegatedTargetNavigatorClusterAttributeListAttributeCallback implements ChipClusters.TargetNavigatorCluster.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 DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback implements ChipClusters.TemperatureMeasurementCluster.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 DelegatedBooleanResponseCallback implements ChipClusters.TestClusterCluster.BooleanResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Boolean value) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Boolean"); - responseValues.put(valueResponseValue, value); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSimpleStructResponseCallback implements ChipClusters.TestClusterCluster.SimpleStructResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1) { - Map responseValues = new LinkedHashMap<>(); - // arg1: Struct SimpleStruct - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestAddArgumentsResponseCallback implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer returnValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo returnValueResponseValue = new CommandResponseInfo("returnValue", "Integer"); - responseValues.put(returnValueResponseValue, returnValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestEmitTestEventResponseCallback implements ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Long value) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Long"); - responseValues.put(valueResponseValue, value); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestEnumsResponseCallback implements ChipClusters.TestClusterCluster.TestEnumsResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer arg1, Integer arg2) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo arg1ResponseValue = new CommandResponseInfo("arg1", "Integer"); - responseValues.put(arg1ResponseValue, arg1); - CommandResponseInfo arg2ResponseValue = new CommandResponseInfo("arg2", "Integer"); - responseValues.put(arg2ResponseValue, arg2); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestListInt8UReverseResponseCallback implements ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ArrayList arg1) { - Map responseValues = new LinkedHashMap<>(); - // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestNullableOptionalResponseCallback implements ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo wasPresentResponseValue = new CommandResponseInfo("wasPresent", "Boolean"); - responseValues.put(wasPresentResponseValue, wasPresent); - CommandResponseInfo wasNullResponseValue = new CommandResponseInfo("wasNull", "Optional"); - responseValues.put(wasNullResponseValue, wasNull); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Optional"); - responseValues.put(valueResponseValue, value); - CommandResponseInfo originalValueResponseValue = new CommandResponseInfo("originalValue", "Optional"); - responseValues.put(originalValueResponseValue, originalValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestSpecificResponseCallback implements ChipClusters.TestClusterCluster.TestSpecificResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer returnValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo returnValueResponseValue = new CommandResponseInfo("returnValue", "Integer"); - responseValues.put(returnValueResponseValue, returnValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedTestClusterClusterListInt8uAttributeCallback implements ChipClusters.TestClusterCluster.ListInt8uAttributeCallback, 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 DelegatedTestClusterClusterListOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback, 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 DelegatedTestClusterClusterListStructOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback, 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 DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback implements ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback, 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 DelegatedTestClusterClusterListLongOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback, 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 DelegatedTestClusterClusterAttributeListAttributeCallback implements ChipClusters.TestClusterCluster.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 DelegatedGetRelayStatusLogResponseCallback implements ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo timeOfDayResponseValue = new CommandResponseInfo("timeOfDay", "Integer"); - responseValues.put(timeOfDayResponseValue, timeOfDay); - CommandResponseInfo relayStatusResponseValue = new CommandResponseInfo("relayStatus", "Integer"); - responseValues.put(relayStatusResponseValue, relayStatus); - CommandResponseInfo localTemperatureResponseValue = new CommandResponseInfo("localTemperature", "Integer"); - responseValues.put(localTemperatureResponseValue, localTemperature); - CommandResponseInfo humidityInPercentageResponseValue = new CommandResponseInfo("humidityInPercentage", "Integer"); - responseValues.put(humidityInPercentageResponseValue, humidityInPercentage); - CommandResponseInfo setpointResponseValue = new CommandResponseInfo("setpoint", "Integer"); - responseValues.put(setpointResponseValue, setpoint); - CommandResponseInfo unreadEntriesResponseValue = new CommandResponseInfo("unreadEntries", "Integer"); - responseValues.put(unreadEntriesResponseValue, unreadEntries); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetWeeklyScheduleResponseCallback implements ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo numberOfTransitionsForSequenceResponseValue = new CommandResponseInfo("numberOfTransitionsForSequence", "Integer"); - responseValues.put(numberOfTransitionsForSequenceResponseValue, numberOfTransitionsForSequence); - CommandResponseInfo dayOfWeekForSequenceResponseValue = new CommandResponseInfo("dayOfWeekForSequence", "Integer"); - responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); - CommandResponseInfo modeForSequenceResponseValue = new CommandResponseInfo("modeForSequence", "Integer"); - responseValues.put(modeForSequenceResponseValue, modeForSequence); - // payload: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedThermostatClusterAttributeListAttributeCallback implements ChipClusters.ThermostatCluster.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 DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback implements ChipClusters.ThermostatUserInterfaceConfigurationCluster.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 DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.OperationalDatasetComponentsAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.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 DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback implements ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback, 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 DelegatedUserLabelClusterLabelListAttributeCallback implements ChipClusters.UserLabelCluster.LabelListAttributeCallback, 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 DelegatedWakeOnLanClusterAttributeListAttributeCallback implements ChipClusters.WakeOnLanCluster.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 DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.WiFiNetworkDiagnosticsCluster.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 DelegatedWindowCoveringClusterAttributeListAttributeCallback implements ChipClusters.WindowCoveringCluster.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 Map getClusterMap() { - Map clusterMap = initializeClusterMap(); - Map> commandMap = getCommandMap(); - combineCommand(clusterMap, commandMap); - Map> readAttributeMap = new ClusterReadMapping().getReadAttributeMap(); - combineCommand(clusterMap, readAttributeMap); - Map> writeAttributeMap = new ClusterWriteMapping().getWriteAttributeMap(); - combineCommand(clusterMap, writeAttributeMap); - return clusterMap; - } + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } - public Map initializeClusterMap() { - Map clusterMap = new HashMap<>(); - ClusterInfo accessControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AccessControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("accessControl", accessControlClusterInfo); - ClusterInfo accountLoginClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("accountLogin", accountLoginClusterInfo); - ClusterInfo administratorCommissioningClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); - ClusterInfo applicationBasicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("applicationBasic", applicationBasicClusterInfo); - ClusterInfo applicationLauncherClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); - ClusterInfo audioOutputClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("audioOutput", audioOutputClusterInfo); - ClusterInfo barrierControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("barrierControl", barrierControlClusterInfo); - ClusterInfo basicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("basic", basicClusterInfo); - ClusterInfo binaryInputBasicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); - ClusterInfo bindingClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("binding", bindingClusterInfo); - ClusterInfo booleanStateClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("booleanState", booleanStateClusterInfo); - ClusterInfo bridgedActionsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("bridgedActions", bridgedActionsClusterInfo); - ClusterInfo bridgedDeviceBasicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); - ClusterInfo channelClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ChannelCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("channel", channelClusterInfo); - ClusterInfo colorControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("colorControl", colorControlClusterInfo); - ClusterInfo contentLauncherClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("contentLauncher", contentLauncherClusterInfo); - ClusterInfo descriptorClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("descriptor", descriptorClusterInfo); - ClusterInfo diagnosticLogsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); - ClusterInfo doorLockClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("doorLock", doorLockClusterInfo); - ClusterInfo electricalMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); - ClusterInfo ethernetNetworkDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); - ClusterInfo fixedLabelClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("fixedLabel", fixedLabelClusterInfo); - ClusterInfo flowMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); - ClusterInfo generalCommissioningClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); - ClusterInfo generalDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); - ClusterInfo groupKeyManagementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); - ClusterInfo groupsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("groups", groupsClusterInfo); - ClusterInfo identifyClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("identify", identifyClusterInfo); - ClusterInfo illuminanceMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); - ClusterInfo keypadInputClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("keypadInput", keypadInputClusterInfo); - ClusterInfo levelControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("levelControl", levelControlClusterInfo); - ClusterInfo localizationConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LocalizationConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("localizationConfiguration", localizationConfigurationClusterInfo); - ClusterInfo lowPowerClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("lowPower", lowPowerClusterInfo); - ClusterInfo mediaInputClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("mediaInput", mediaInputClusterInfo); - ClusterInfo mediaPlaybackClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); - ClusterInfo modeSelectClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("modeSelect", modeSelectClusterInfo); - ClusterInfo networkCommissioningClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); - ClusterInfo otaSoftwareUpdateProviderClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); - ClusterInfo otaSoftwareUpdateRequestorClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); - ClusterInfo occupancySensingClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("occupancySensing", occupancySensingClusterInfo); - ClusterInfo onOffClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("onOff", onOffClusterInfo); - ClusterInfo onOffSwitchConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); - ClusterInfo operationalCredentialsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); - ClusterInfo powerSourceClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("powerSource", powerSourceClusterInfo); - ClusterInfo powerSourceConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PowerSourceConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInfo); - ClusterInfo pressureMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); - ClusterInfo pumpConfigurationAndControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); - ClusterInfo relativeHumidityMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); - ClusterInfo scenesClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("scenes", scenesClusterInfo); - ClusterInfo softwareDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); - ClusterInfo switchClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("switch", switchClusterInfo); - ClusterInfo targetNavigatorClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("targetNavigator", targetNavigatorClusterInfo); - ClusterInfo temperatureMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); - ClusterInfo testClusterClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("testCluster", testClusterClusterInfo); - ClusterInfo thermostatClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("thermostat", thermostatClusterInfo); - ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); - ClusterInfo threadNetworkDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); - ClusterInfo timeFormatLocalizationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TimeFormatLocalizationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("timeFormatLocalization", timeFormatLocalizationClusterInfo); - ClusterInfo unitLocalizationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.UnitLocalizationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("unitLocalization", unitLocalizationClusterInfo); - ClusterInfo userLabelClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.UserLabelCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("userLabel", userLabelClusterInfo); - ClusterInfo wakeOnLanClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); - ClusterInfo wiFiNetworkDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); - ClusterInfo windowCoveringClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("windowCovering", windowCoveringClusterInfo); - return clusterMap; - } - - public void combineCommand(Map destination, Map> source) { - destination.get("accessControl").combineCommands(source.get("accessControl")); - destination.get("accountLogin").combineCommands(source.get("accountLogin")); - destination.get("administratorCommissioning").combineCommands(source.get("administratorCommissioning")); - destination.get("applicationBasic").combineCommands(source.get("applicationBasic")); - destination.get("applicationLauncher").combineCommands(source.get("applicationLauncher")); - destination.get("audioOutput").combineCommands(source.get("audioOutput")); - destination.get("barrierControl").combineCommands(source.get("barrierControl")); - destination.get("basic").combineCommands(source.get("basic")); - destination.get("binaryInputBasic").combineCommands(source.get("binaryInputBasic")); - destination.get("binding").combineCommands(source.get("binding")); - destination.get("booleanState").combineCommands(source.get("booleanState")); - destination.get("bridgedActions").combineCommands(source.get("bridgedActions")); - destination.get("bridgedDeviceBasic").combineCommands(source.get("bridgedDeviceBasic")); - destination.get("channel").combineCommands(source.get("channel")); - destination.get("colorControl").combineCommands(source.get("colorControl")); - destination.get("contentLauncher").combineCommands(source.get("contentLauncher")); - destination.get("descriptor").combineCommands(source.get("descriptor")); - destination.get("diagnosticLogs").combineCommands(source.get("diagnosticLogs")); - destination.get("doorLock").combineCommands(source.get("doorLock")); - destination.get("electricalMeasurement").combineCommands(source.get("electricalMeasurement")); - destination.get("ethernetNetworkDiagnostics").combineCommands(source.get("ethernetNetworkDiagnostics")); - destination.get("fixedLabel").combineCommands(source.get("fixedLabel")); - destination.get("flowMeasurement").combineCommands(source.get("flowMeasurement")); - destination.get("generalCommissioning").combineCommands(source.get("generalCommissioning")); - destination.get("generalDiagnostics").combineCommands(source.get("generalDiagnostics")); - destination.get("groupKeyManagement").combineCommands(source.get("groupKeyManagement")); - destination.get("groups").combineCommands(source.get("groups")); - destination.get("identify").combineCommands(source.get("identify")); - destination.get("illuminanceMeasurement").combineCommands(source.get("illuminanceMeasurement")); - destination.get("keypadInput").combineCommands(source.get("keypadInput")); - destination.get("levelControl").combineCommands(source.get("levelControl")); - destination.get("localizationConfiguration").combineCommands(source.get("localizationConfiguration")); - destination.get("lowPower").combineCommands(source.get("lowPower")); - destination.get("mediaInput").combineCommands(source.get("mediaInput")); - destination.get("mediaPlayback").combineCommands(source.get("mediaPlayback")); - destination.get("modeSelect").combineCommands(source.get("modeSelect")); - destination.get("networkCommissioning").combineCommands(source.get("networkCommissioning")); - destination.get("otaSoftwareUpdateProvider").combineCommands(source.get("otaSoftwareUpdateProvider")); - destination.get("otaSoftwareUpdateRequestor").combineCommands(source.get("otaSoftwareUpdateRequestor")); - destination.get("occupancySensing").combineCommands(source.get("occupancySensing")); - destination.get("onOff").combineCommands(source.get("onOff")); - destination.get("onOffSwitchConfiguration").combineCommands(source.get("onOffSwitchConfiguration")); - destination.get("operationalCredentials").combineCommands(source.get("operationalCredentials")); - destination.get("powerSource").combineCommands(source.get("powerSource")); - destination.get("powerSourceConfiguration").combineCommands(source.get("powerSourceConfiguration")); - destination.get("pressureMeasurement").combineCommands(source.get("pressureMeasurement")); - destination.get("pumpConfigurationAndControl").combineCommands(source.get("pumpConfigurationAndControl")); - destination.get("relativeHumidityMeasurement").combineCommands(source.get("relativeHumidityMeasurement")); - destination.get("scenes").combineCommands(source.get("scenes")); - destination.get("softwareDiagnostics").combineCommands(source.get("softwareDiagnostics")); - destination.get("switch").combineCommands(source.get("switch")); - destination.get("targetNavigator").combineCommands(source.get("targetNavigator")); - destination.get("temperatureMeasurement").combineCommands(source.get("temperatureMeasurement")); - destination.get("testCluster").combineCommands(source.get("testCluster")); - destination.get("thermostat").combineCommands(source.get("thermostat")); - destination.get("thermostatUserInterfaceConfiguration").combineCommands(source.get("thermostatUserInterfaceConfiguration")); - destination.get("threadNetworkDiagnostics").combineCommands(source.get("threadNetworkDiagnostics")); - destination.get("timeFormatLocalization").combineCommands(source.get("timeFormatLocalization")); - destination.get("unitLocalization").combineCommands(source.get("unitLocalization")); - destination.get("userLabel").combineCommands(source.get("userLabel")); - destination.get("wakeOnLan").combineCommands(source.get("wakeOnLan")); - destination.get("wiFiNetworkDiagnostics").combineCommands(source.get("wiFiNetworkDiagnostics")); - destination.get("windowCovering").combineCommands(source.get("windowCovering")); - } - - @SuppressWarnings("unchecked") - public Map> getCommandMap() { - Map> commandMap = new HashMap<>(); - Map accessControlClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("accessControl", accessControlClusterInteractionInfoMap); - Map accountLoginClusterInteractionInfoMap = new LinkedHashMap<>(); - Map accountLogingetSetupPINRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); - accountLogingetSetupPINRequestCommandParams.put("tempAccountIdentifier",accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); - - InteractionInfo accountLogingetSetupPINRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .getSetupPINRequest((ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback) callback - , (String) - commandArguments.get("tempAccountIdentifier") - , 10000 - ); - }, - () -> new DelegatedGetSetupPINResponseCallback(), - accountLogingetSetupPINRequestCommandParams - ); - accountLoginClusterInteractionInfoMap.put("getSetupPINRequest", accountLogingetSetupPINRequestInteractionInfo); - Map accountLoginloginRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); - accountLoginloginRequestCommandParams.put("tempAccountIdentifier",accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); - - CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = new CommandParameterInfo("setupPIN", String.class); - accountLoginloginRequestCommandParams.put("setupPIN",accountLoginloginRequestsetupPINCommandParameterInfo); - - InteractionInfo accountLoginloginRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .loginRequest((DefaultClusterCallback) callback - , (String) - commandArguments.get("tempAccountIdentifier") - , (String) - commandArguments.get("setupPIN") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - accountLoginloginRequestCommandParams - ); - accountLoginClusterInteractionInfoMap.put("loginRequest", accountLoginloginRequestInteractionInfo); - Map accountLoginlogoutRequestCommandParams = new LinkedHashMap(); - InteractionInfo accountLoginlogoutRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .logoutRequest((DefaultClusterCallback) callback - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - accountLoginlogoutRequestCommandParams - ); - accountLoginClusterInteractionInfoMap.put("logoutRequest", accountLoginlogoutRequestInteractionInfo); - commandMap.put("accountLogin", accountLoginClusterInteractionInfoMap); - Map administratorCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); - Map administratorCommissioningopenBasicCommissioningWindowCommandParams = new LinkedHashMap(); - CommandParameterInfo administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); - administratorCommissioningopenBasicCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); - - InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .openBasicCommissioningWindow((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("commissioningTimeout") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningopenBasicCommissioningWindowCommandParams - ); - administratorCommissioningClusterInteractionInfoMap.put("openBasicCommissioningWindow", administratorCommissioningopenBasicCommissioningWindowInteractionInfo); - Map administratorCommissioningopenCommissioningWindowCommandParams = new LinkedHashMap(); - CommandParameterInfo administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = new CommandParameterInfo("PAKEVerifier", byte[].class); - administratorCommissioningopenCommissioningWindowCommandParams.put("PAKEVerifier",administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = new CommandParameterInfo("discriminator", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("discriminator",administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = new CommandParameterInfo("iterations", Long.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("iterations",administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = new CommandParameterInfo("salt", byte[].class); - administratorCommissioningopenCommissioningWindowCommandParams.put("salt",administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = new CommandParameterInfo("passcodeID", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("passcodeID",administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); - - InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .openCommissioningWindow((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("commissioningTimeout") - , (byte[]) - commandArguments.get("PAKEVerifier") - , (Integer) - commandArguments.get("discriminator") - , (Long) - commandArguments.get("iterations") - , (byte[]) - commandArguments.get("salt") - , (Integer) - commandArguments.get("passcodeID") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningopenCommissioningWindowCommandParams - ); - administratorCommissioningClusterInteractionInfoMap.put("openCommissioningWindow", administratorCommissioningopenCommissioningWindowInteractionInfo); - Map administratorCommissioningrevokeCommissioningCommandParams = new LinkedHashMap(); - InteractionInfo administratorCommissioningrevokeCommissioningInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .revokeCommissioning((DefaultClusterCallback) callback - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningrevokeCommissioningCommandParams - ); - administratorCommissioningClusterInteractionInfoMap.put("revokeCommissioning", administratorCommissioningrevokeCommissioningInteractionInfo); - commandMap.put("administratorCommissioning", administratorCommissioningClusterInteractionInfoMap); - Map applicationBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("applicationBasic", applicationBasicClusterInteractionInfoMap); - Map applicationLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); - Map applicationLauncherhideAppRequestCommandParams = new LinkedHashMap(); - InteractionInfo applicationLauncherhideAppRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .hideAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback - , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application") - - ); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherhideAppRequestCommandParams - ); - applicationLauncherClusterInteractionInfoMap.put("hideAppRequest", applicationLauncherhideAppRequestInteractionInfo); - Map applicationLauncherlaunchAppRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); - applicationLauncherlaunchAppRequestCommandParams.put("data",applicationLauncherlaunchAppRequestdataCommandParameterInfo); - - InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .launchAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback - , (String) - commandArguments.get("data") - , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application") - - ); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherlaunchAppRequestCommandParams - ); - applicationLauncherClusterInteractionInfoMap.put("launchAppRequest", applicationLauncherlaunchAppRequestInteractionInfo); - Map applicationLauncherstopAppRequestCommandParams = new LinkedHashMap(); - InteractionInfo applicationLauncherstopAppRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .stopAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback - , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application") - - ); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherstopAppRequestCommandParams - ); - applicationLauncherClusterInteractionInfoMap.put("stopAppRequest", applicationLauncherstopAppRequestInteractionInfo); - commandMap.put("applicationLauncher", applicationLauncherClusterInteractionInfoMap); - Map audioOutputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map audioOutputrenameOutputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - audioOutputrenameOutputRequestCommandParams.put("index",audioOutputrenameOutputRequestindexCommandParameterInfo); - - CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); - audioOutputrenameOutputRequestCommandParams.put("name",audioOutputrenameOutputRequestnameCommandParameterInfo); - - InteractionInfo audioOutputrenameOutputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .renameOutputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - , (String) - commandArguments.get("name") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - audioOutputrenameOutputRequestCommandParams - ); - audioOutputClusterInteractionInfoMap.put("renameOutputRequest", audioOutputrenameOutputRequestInteractionInfo); - Map audioOutputselectOutputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - audioOutputselectOutputRequestCommandParams.put("index",audioOutputselectOutputRequestindexCommandParameterInfo); - - InteractionInfo audioOutputselectOutputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .selectOutputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - audioOutputselectOutputRequestCommandParams - ); - audioOutputClusterInteractionInfoMap.put("selectOutputRequest", audioOutputselectOutputRequestInteractionInfo); - commandMap.put("audioOutput", audioOutputClusterInteractionInfoMap); - Map barrierControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map barrierControlbarrierControlGoToPercentCommandParams = new LinkedHashMap(); - CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = new CommandParameterInfo("percentOpen", Integer.class); - barrierControlbarrierControlGoToPercentCommandParams.put("percentOpen",barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); - - InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .barrierControlGoToPercent((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("percentOpen") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - barrierControlbarrierControlGoToPercentCommandParams - ); - barrierControlClusterInteractionInfoMap.put("barrierControlGoToPercent", barrierControlbarrierControlGoToPercentInteractionInfo); - Map barrierControlbarrierControlStopCommandParams = new LinkedHashMap(); - InteractionInfo barrierControlbarrierControlStopInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .barrierControlStop((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - barrierControlbarrierControlStopCommandParams - ); - barrierControlClusterInteractionInfoMap.put("barrierControlStop", barrierControlbarrierControlStopInteractionInfo); - commandMap.put("barrierControl", barrierControlClusterInteractionInfoMap); - Map basicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("basic", basicClusterInteractionInfoMap); - Map binaryInputBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("binaryInputBasic", binaryInputBasicClusterInteractionInfoMap); - Map bindingClusterInteractionInfoMap = new LinkedHashMap<>(); - Map bindingbindCommandParams = new LinkedHashMap(); - CommandParameterInfo bindingbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); - bindingbindCommandParams.put("nodeId",bindingbindnodeIdCommandParameterInfo); - - CommandParameterInfo bindingbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - bindingbindCommandParams.put("groupId",bindingbindgroupIdCommandParameterInfo); - - CommandParameterInfo bindingbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); - bindingbindCommandParams.put("endpointId",bindingbindendpointIdCommandParameterInfo); - - CommandParameterInfo bindingbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); - bindingbindCommandParams.put("clusterId",bindingbindclusterIdCommandParameterInfo); - - InteractionInfo bindingbindInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .bind((DefaultClusterCallback) callback - , (Long) - commandArguments.get("nodeId") - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("endpointId") - , (Long) - commandArguments.get("clusterId") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bindingbindCommandParams - ); - bindingClusterInteractionInfoMap.put("bind", bindingbindInteractionInfo); - Map bindingunbindCommandParams = new LinkedHashMap(); - CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); - bindingunbindCommandParams.put("nodeId",bindingunbindnodeIdCommandParameterInfo); - - CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - bindingunbindCommandParams.put("groupId",bindingunbindgroupIdCommandParameterInfo); - - CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); - bindingunbindCommandParams.put("endpointId",bindingunbindendpointIdCommandParameterInfo); - - CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); - bindingunbindCommandParams.put("clusterId",bindingunbindclusterIdCommandParameterInfo); - - InteractionInfo bindingunbindInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .unbind((DefaultClusterCallback) callback - , (Long) - commandArguments.get("nodeId") - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("endpointId") - , (Long) - commandArguments.get("clusterId") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bindingunbindCommandParams - ); - bindingClusterInteractionInfoMap.put("unbind", bindingunbindInteractionInfo); - commandMap.put("binding", bindingClusterInteractionInfoMap); - Map booleanStateClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("booleanState", booleanStateClusterInteractionInfoMap); - Map bridgedActionsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map bridgedActionsdisableActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsdisableActionCommandParams.put("actionID",bridgedActionsdisableActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsdisableActionCommandParams.put("invokeID",bridgedActionsdisableActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsdisableActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .disableAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsdisableActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("disableAction", bridgedActionsdisableActionInteractionInfo); - Map bridgedActionsdisableActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsdisableActionWithDurationCommandParams.put("actionID",bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsdisableActionWithDurationCommandParams.put("invokeID",bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionsdisableActionWithDurationCommandParams.put("duration",bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .disableActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsdisableActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("disableActionWithDuration", bridgedActionsdisableActionWithDurationInteractionInfo); - Map bridgedActionsenableActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsenableActionCommandParams.put("actionID",bridgedActionsenableActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsenableActionCommandParams.put("invokeID",bridgedActionsenableActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsenableActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .enableAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsenableActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("enableAction", bridgedActionsenableActionInteractionInfo); - Map bridgedActionsenableActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsenableActionWithDurationCommandParams.put("actionID",bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsenableActionWithDurationCommandParams.put("invokeID",bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionsenableActionWithDurationCommandParams.put("duration",bridgedActionsenableActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .enableActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsenableActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("enableActionWithDuration", bridgedActionsenableActionWithDurationInteractionInfo); - Map bridgedActionsinstantActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsinstantActionCommandParams.put("actionID",bridgedActionsinstantActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsinstantActionCommandParams.put("invokeID",bridgedActionsinstantActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsinstantActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .instantAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsinstantActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("instantAction", bridgedActionsinstantActionInteractionInfo); - Map bridgedActionsinstantActionWithTransitionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsinstantActionWithTransitionCommandParams.put("actionID",bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsinstantActionWithTransitionCommandParams.put("invokeID",bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - bridgedActionsinstantActionWithTransitionCommandParams.put("transitionTime",bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); - - InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .instantActionWithTransition((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsinstantActionWithTransitionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("instantActionWithTransition", bridgedActionsinstantActionWithTransitionInteractionInfo); - Map bridgedActionspauseActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionspauseActionCommandParams.put("actionID",bridgedActionspauseActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionspauseActionCommandParams.put("invokeID",bridgedActionspauseActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionspauseActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .pauseAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionspauseActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("pauseAction", bridgedActionspauseActionInteractionInfo); - Map bridgedActionspauseActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionspauseActionWithDurationCommandParams.put("actionID",bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionspauseActionWithDurationCommandParams.put("invokeID",bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionspauseActionWithDurationCommandParams.put("duration",bridgedActionspauseActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .pauseActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionspauseActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("pauseActionWithDuration", bridgedActionspauseActionWithDurationInteractionInfo); - Map bridgedActionsresumeActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsresumeActionCommandParams.put("actionID",bridgedActionsresumeActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsresumeActionCommandParams.put("invokeID",bridgedActionsresumeActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsresumeActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .resumeAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsresumeActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("resumeAction", bridgedActionsresumeActionInteractionInfo); - Map bridgedActionsstartActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstartActionCommandParams.put("actionID",bridgedActionsstartActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstartActionCommandParams.put("invokeID",bridgedActionsstartActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsstartActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .startAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstartActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("startAction", bridgedActionsstartActionInteractionInfo); - Map bridgedActionsstartActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstartActionWithDurationCommandParams.put("actionID",bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstartActionWithDurationCommandParams.put("invokeID",bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionsstartActionWithDurationCommandParams.put("duration",bridgedActionsstartActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .startActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstartActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("startActionWithDuration", bridgedActionsstartActionWithDurationInteractionInfo); - Map bridgedActionsstopActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstopActionCommandParams.put("actionID",bridgedActionsstopActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstopActionCommandParams.put("invokeID",bridgedActionsstopActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsstopActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .stopAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstopActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("stopAction", bridgedActionsstopActionInteractionInfo); - commandMap.put("bridgedActions", bridgedActionsClusterInteractionInfoMap); - Map bridgedDeviceBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInteractionInfoMap); - Map channelClusterInteractionInfoMap = new LinkedHashMap<>(); - Map channelchangeChannelByNumberRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = new CommandParameterInfo("majorNumber", Integer.class); - channelchangeChannelByNumberRequestCommandParams.put("majorNumber",channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); - - CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = new CommandParameterInfo("minorNumber", Integer.class); - channelchangeChannelByNumberRequestCommandParams.put("minorNumber",channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); - - InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .changeChannelByNumberRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("majorNumber") - , (Integer) - commandArguments.get("minorNumber") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - channelchangeChannelByNumberRequestCommandParams - ); - channelClusterInteractionInfoMap.put("changeChannelByNumberRequest", channelchangeChannelByNumberRequestInteractionInfo); - Map channelchangeChannelRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = new CommandParameterInfo("match", String.class); - channelchangeChannelRequestCommandParams.put("match",channelchangeChannelRequestmatchCommandParameterInfo); - - InteractionInfo channelchangeChannelRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .changeChannelRequest((ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback - , (String) - commandArguments.get("match") - - ); - }, - () -> new DelegatedChangeChannelResponseCallback(), - channelchangeChannelRequestCommandParams - ); - channelClusterInteractionInfoMap.put("changeChannelRequest", channelchangeChannelRequestInteractionInfo); - Map channelskipChannelRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = new CommandParameterInfo("count", Integer.class); - channelskipChannelRequestCommandParams.put("count",channelskipChannelRequestcountCommandParameterInfo); - - InteractionInfo channelskipChannelRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .skipChannelRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("count") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - channelskipChannelRequestCommandParams - ); - channelClusterInteractionInfoMap.put("skipChannelRequest", channelskipChannelRequestInteractionInfo); - commandMap.put("channel", channelClusterInteractionInfoMap); - Map colorControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map colorControlcolorLoopSetCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = new CommandParameterInfo("updateFlags", Integer.class); - colorControlcolorLoopSetCommandParams.put("updateFlags",colorControlcolorLoopSetupdateFlagsCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = new CommandParameterInfo("action", Integer.class); - colorControlcolorLoopSetCommandParams.put("action",colorControlcolorLoopSetactionCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); - colorControlcolorLoopSetCommandParams.put("direction",colorControlcolorLoopSetdirectionCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = new CommandParameterInfo("time", Integer.class); - colorControlcolorLoopSetCommandParams.put("time",colorControlcolorLoopSettimeCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = new CommandParameterInfo("startHue", Integer.class); - colorControlcolorLoopSetCommandParams.put("startHue",colorControlcolorLoopSetstartHueCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlcolorLoopSetCommandParams.put("optionsMask",colorControlcolorLoopSetoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlcolorLoopSetCommandParams.put("optionsOverride",colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlcolorLoopSetInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .colorLoopSet((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("updateFlags") - , (Integer) - commandArguments.get("action") - , (Integer) - commandArguments.get("direction") - , (Integer) - commandArguments.get("time") - , (Integer) - commandArguments.get("startHue") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlcolorLoopSetCommandParams - ); - colorControlClusterInteractionInfoMap.put("colorLoopSet", colorControlcolorLoopSetInteractionInfo); - Map colorControlenhancedMoveHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlenhancedMoveHueCommandParams.put("moveMode",colorControlenhancedMoveHuemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlenhancedMoveHueCommandParams.put("rate",colorControlenhancedMoveHuerateCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveHueCommandParams.put("optionsMask",colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveHueCommandParams.put("optionsOverride",colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedMoveHue", colorControlenhancedMoveHueInteractionInfo); - Map colorControlenhancedMoveToHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("enhancedHue",colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("direction",colorControlenhancedMoveToHuedirectionCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("transitionTime",colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("optionsMask",colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("optionsOverride",colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveToHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveToHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("enhancedHue") - , (Integer) - commandArguments.get("direction") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveToHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedMoveToHue", colorControlenhancedMoveToHueInteractionInfo); - Map colorControlenhancedMoveToHueAndSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("enhancedHue",colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("saturation",colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("transitionTime",colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsMask",colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveToHueAndSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("enhancedHue") - , (Integer) - commandArguments.get("saturation") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveToHueAndSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedMoveToHueAndSaturation", colorControlenhancedMoveToHueAndSaturationInteractionInfo); - Map colorControlenhancedStepHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlenhancedStepHueCommandParams.put("stepMode",colorControlenhancedStepHuestepModeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlenhancedStepHueCommandParams.put("stepSize",colorControlenhancedStepHuestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedStepHueCommandParams.put("transitionTime",colorControlenhancedStepHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedStepHueCommandParams.put("optionsMask",colorControlenhancedStepHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedStepHueCommandParams.put("optionsOverride",colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedStepHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedStepHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedStepHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedStepHue", colorControlenhancedStepHueInteractionInfo); - Map colorControlmoveColorCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = new CommandParameterInfo("rateX", Integer.class); - colorControlmoveColorCommandParams.put("rateX",colorControlmoveColorrateXCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = new CommandParameterInfo("rateY", Integer.class); - colorControlmoveColorCommandParams.put("rateY",colorControlmoveColorrateYCommandParameterInfo); - - CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveColorCommandParams.put("optionsMask",colorControlmoveColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveColorCommandParams.put("optionsOverride",colorControlmoveColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveColorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveColor((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("rateX") - , (Integer) - commandArguments.get("rateY") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveColorCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveColor", colorControlmoveColorInteractionInfo); - Map colorControlmoveColorTemperatureCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("moveMode",colorControlmoveColorTemperaturemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("rate",colorControlmoveColorTemperaturerateCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("optionsMask",colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("optionsOverride",colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveColorTemperatureInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveColorTemperature((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("colorTemperatureMinimum") - , (Integer) - commandArguments.get("colorTemperatureMaximum") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveColorTemperatureCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveColorTemperature", colorControlmoveColorTemperatureInteractionInfo); - Map colorControlmoveHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveHueCommandParams.put("moveMode",colorControlmoveHuemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlmoveHueCommandParams.put("rate",colorControlmoveHuerateCommandParameterInfo); - - CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveHueCommandParams.put("optionsMask",colorControlmoveHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveHueCommandParams.put("optionsOverride",colorControlmoveHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveHue", colorControlmoveHueInteractionInfo); - Map colorControlmoveSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveSaturationCommandParams.put("moveMode",colorControlmoveSaturationmoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlmoveSaturationCommandParams.put("rate",colorControlmoveSaturationrateCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveSaturationCommandParams.put("optionsMask",colorControlmoveSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveSaturationCommandParams.put("optionsOverride",colorControlmoveSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveSaturation", colorControlmoveSaturationInteractionInfo); - Map colorControlmoveToColorCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = new CommandParameterInfo("colorX", Integer.class); - colorControlmoveToColorCommandParams.put("colorX",colorControlmoveToColorcolorXCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = new CommandParameterInfo("colorY", Integer.class); - colorControlmoveToColorCommandParams.put("colorY",colorControlmoveToColorcolorYCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToColorCommandParams.put("transitionTime",colorControlmoveToColortransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToColorCommandParams.put("optionsMask",colorControlmoveToColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToColorCommandParams.put("optionsOverride",colorControlmoveToColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToColorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToColor((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("colorX") - , (Integer) - commandArguments.get("colorY") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToColorCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToColor", colorControlmoveToColorInteractionInfo); - Map colorControlmoveToColorTemperatureCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = new CommandParameterInfo("colorTemperature", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("colorTemperature",colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("transitionTime",colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("optionsMask",colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("optionsOverride",colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToColorTemperature((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("colorTemperature") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToColorTemperatureCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToColorTemperature", colorControlmoveToColorTemperatureInteractionInfo); - Map colorControlmoveToHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); - colorControlmoveToHueCommandParams.put("hue",colorControlmoveToHuehueCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); - colorControlmoveToHueCommandParams.put("direction",colorControlmoveToHuedirectionCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToHueCommandParams.put("transitionTime",colorControlmoveToHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToHueCommandParams.put("optionsMask",colorControlmoveToHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToHueCommandParams.put("optionsOverride",colorControlmoveToHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("hue") - , (Integer) - commandArguments.get("direction") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToHue", colorControlmoveToHueInteractionInfo); - Map colorControlmoveToHueAndSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("hue",colorControlmoveToHueAndSaturationhueCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("saturation",colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("transitionTime",colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("optionsMask",colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToHueAndSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("hue") - , (Integer) - commandArguments.get("saturation") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToHueAndSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToHueAndSaturation", colorControlmoveToHueAndSaturationInteractionInfo); - Map colorControlmoveToSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); - colorControlmoveToSaturationCommandParams.put("saturation",colorControlmoveToSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToSaturationCommandParams.put("transitionTime",colorControlmoveToSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToSaturationCommandParams.put("optionsMask",colorControlmoveToSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToSaturationCommandParams.put("optionsOverride",colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("saturation") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToSaturation", colorControlmoveToSaturationInteractionInfo); - Map colorControlstepColorCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = new CommandParameterInfo("stepX", Integer.class); - colorControlstepColorCommandParams.put("stepX",colorControlstepColorstepXCommandParameterInfo); - - CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = new CommandParameterInfo("stepY", Integer.class); - colorControlstepColorCommandParams.put("stepY",colorControlstepColorstepYCommandParameterInfo); - - CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepColorCommandParams.put("transitionTime",colorControlstepColortransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepColorCommandParams.put("optionsMask",colorControlstepColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepColorCommandParams.put("optionsOverride",colorControlstepColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepColorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepColor((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepX") - , (Integer) - commandArguments.get("stepY") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepColorCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepColor", colorControlstepColorInteractionInfo); - Map colorControlstepColorTemperatureCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlstepColorTemperatureCommandParams.put("stepMode",colorControlstepColorTemperaturestepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlstepColorTemperatureCommandParams.put("stepSize",colorControlstepColorTemperaturestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepColorTemperatureCommandParams.put("transitionTime",colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); - colorControlstepColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); - colorControlstepColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepColorTemperatureCommandParams.put("optionsMask",colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepColorTemperatureCommandParams.put("optionsOverride",colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepColorTemperatureInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepColorTemperature((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("colorTemperatureMinimum") - , (Integer) - commandArguments.get("colorTemperatureMaximum") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepColorTemperatureCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepColorTemperature", colorControlstepColorTemperatureInteractionInfo); - Map colorControlstepHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlstepHueCommandParams.put("stepMode",colorControlstepHuestepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlstepHueCommandParams.put("stepSize",colorControlstepHuestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepHueCommandParams.put("transitionTime",colorControlstepHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepHueCommandParams.put("optionsMask",colorControlstepHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepHueCommandParams.put("optionsOverride",colorControlstepHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepHue", colorControlstepHueInteractionInfo); - Map colorControlstepSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlstepSaturationCommandParams.put("stepMode",colorControlstepSaturationstepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlstepSaturationCommandParams.put("stepSize",colorControlstepSaturationstepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepSaturationCommandParams.put("transitionTime",colorControlstepSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepSaturationCommandParams.put("optionsMask",colorControlstepSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepSaturationCommandParams.put("optionsOverride",colorControlstepSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepSaturation", colorControlstepSaturationInteractionInfo); - Map colorControlstopMoveStepCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstopMoveStepCommandParams.put("optionsMask",colorControlstopMoveStepoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstopMoveStepCommandParams.put("optionsOverride",colorControlstopMoveStepoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstopMoveStepInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stopMoveStep((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstopMoveStepCommandParams - ); - colorControlClusterInteractionInfoMap.put("stopMoveStep", colorControlstopMoveStepInteractionInfo); - commandMap.put("colorControl", colorControlClusterInteractionInfoMap); - Map contentLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); - Map contentLauncherlaunchContentRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = new CommandParameterInfo("autoPlay", Boolean.class); - contentLauncherlaunchContentRequestCommandParams.put("autoPlay",contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); - - CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); - contentLauncherlaunchContentRequestCommandParams.put("data",contentLauncherlaunchContentRequestdataCommandParameterInfo); - - InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .launchContentRequest((ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback - , (Boolean) - commandArguments.get("autoPlay") - , (String) - commandArguments.get("data") - , (ArrayList) - commandArguments.get("search") - - ); - }, - () -> new DelegatedLaunchResponseCallback(), - contentLauncherlaunchContentRequestCommandParams - ); - contentLauncherClusterInteractionInfoMap.put("launchContentRequest", contentLauncherlaunchContentRequestInteractionInfo); - Map contentLauncherlaunchURLRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = new CommandParameterInfo("contentURL", String.class); - contentLauncherlaunchURLRequestCommandParams.put("contentURL",contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); - - CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = new CommandParameterInfo("displayString", String.class); - contentLauncherlaunchURLRequestCommandParams.put("displayString",contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); - - InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .launchURLRequest((ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback - , (String) - commandArguments.get("contentURL") - , (String) - commandArguments.get("displayString") - , (ChipStructs.ContentLauncherClusterBrandingInformation) - commandArguments.get("brandingInformation") - - ); - }, - () -> new DelegatedLaunchResponseCallback(), - contentLauncherlaunchURLRequestCommandParams - ); - contentLauncherClusterInteractionInfoMap.put("launchURLRequest", contentLauncherlaunchURLRequestInteractionInfo); - commandMap.put("contentLauncher", contentLauncherClusterInteractionInfoMap); - Map descriptorClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("descriptor", descriptorClusterInteractionInfoMap); - Map diagnosticLogsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map diagnosticLogsretrieveLogsRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = new CommandParameterInfo("intent", Integer.class); - diagnosticLogsretrieveLogsRequestCommandParams.put("intent",diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); - - CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = new CommandParameterInfo("requestedProtocol", Integer.class); - diagnosticLogsretrieveLogsRequestCommandParams.put("requestedProtocol",diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); - - CommandParameterInfo diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = new CommandParameterInfo("transferFileDesignator", byte[].class); - diagnosticLogsretrieveLogsRequestCommandParams.put("transferFileDesignator",diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); - - InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .retrieveLogsRequest((ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback) callback - , (Integer) - commandArguments.get("intent") - , (Integer) - commandArguments.get("requestedProtocol") - , (byte[]) - commandArguments.get("transferFileDesignator") - - ); - }, - () -> new DelegatedRetrieveLogsResponseCallback(), - diagnosticLogsretrieveLogsRequestCommandParams - ); - diagnosticLogsClusterInteractionInfoMap.put("retrieveLogsRequest", diagnosticLogsretrieveLogsRequestInteractionInfo); - commandMap.put("diagnosticLogs", diagnosticLogsClusterInteractionInfoMap); - Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); - Map doorLockclearCredentialCommandParams = new LinkedHashMap(); - InteractionInfo doorLockclearCredentialInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearCredential((DefaultClusterCallback) callback - , (ChipStructs.DoorLockClusterDlCredential) - commandArguments.get("credential") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearCredentialCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearCredential", doorLockclearCredentialInteractionInfo); - Map doorLockclearUserCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockclearUserCommandParams.put("userIndex",doorLockclearUseruserIndexCommandParameterInfo); - - InteractionInfo doorLockclearUserInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearUser((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("userIndex") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearUserCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearUser", doorLockclearUserInteractionInfo); - Map doorLockclearWeekDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); - doorLockclearWeekDayScheduleCommandParams.put("weekDayIndex",doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockclearWeekDayScheduleCommandParams.put("userIndex",doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearWeekDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("weekDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearWeekDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearWeekDaySchedule", doorLockclearWeekDayScheduleInteractionInfo); - Map doorLockclearYearDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); - doorLockclearYearDayScheduleCommandParams.put("yearDayIndex",doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockclearYearDayScheduleCommandParams.put("userIndex",doorLockclearYearDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockclearYearDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearYearDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("yearDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearYearDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearYearDaySchedule", doorLockclearYearDayScheduleInteractionInfo); - Map doorLockgetCredentialStatusCommandParams = new LinkedHashMap(); - InteractionInfo doorLockgetCredentialStatusInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getCredentialStatus((ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback - , (ChipStructs.DoorLockClusterDlCredential) - commandArguments.get("credential") - - ); - }, - () -> new DelegatedGetCredentialStatusResponseCallback(), - doorLockgetCredentialStatusCommandParams - ); - doorLockClusterInteractionInfoMap.put("getCredentialStatus", doorLockgetCredentialStatusInteractionInfo); - Map doorLockgetUserCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockgetUserCommandParams.put("userIndex",doorLockgetUseruserIndexCommandParameterInfo); - - InteractionInfo doorLockgetUserInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getUser((ChipClusters.DoorLockCluster.GetUserResponseCallback) callback - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedGetUserResponseCallback(), - doorLockgetUserCommandParams - ); - doorLockClusterInteractionInfoMap.put("getUser", doorLockgetUserInteractionInfo); - Map doorLockgetWeekDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); - doorLockgetWeekDayScheduleCommandParams.put("weekDayIndex",doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockgetWeekDayScheduleCommandParams.put("userIndex",doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getWeekDaySchedule((ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback) callback - , (Integer) - commandArguments.get("weekDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedGetWeekDayScheduleResponseCallback(), - doorLockgetWeekDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("getWeekDaySchedule", doorLockgetWeekDayScheduleInteractionInfo); - Map doorLockgetYearDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); - doorLockgetYearDayScheduleCommandParams.put("yearDayIndex",doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockgetYearDayScheduleCommandParams.put("userIndex",doorLockgetYearDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockgetYearDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getYearDaySchedule((ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback) callback - , (Integer) - commandArguments.get("yearDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedGetYearDayScheduleResponseCallback(), - doorLockgetYearDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("getYearDaySchedule", doorLockgetYearDayScheduleInteractionInfo); - Map doorLocklockDoorCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); - doorLocklockDoorCommandParams.put("pinCode",doorLocklockDoorpinCodeCommandParameterInfo); - - InteractionInfo doorLocklockDoorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .lockDoor((DefaultClusterCallback) callback - , (Optional) - commandArguments.get("pinCode") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocklockDoorCommandParams - ); - doorLockClusterInteractionInfoMap.put("lockDoor", doorLocklockDoorInteractionInfo); - Map doorLocksetCredentialCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); - doorLocksetCredentialCommandParams.put("operationType",doorLocksetCredentialoperationTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = new CommandParameterInfo("credentialData", byte[].class); - doorLocksetCredentialCommandParams.put("credentialData",doorLocksetCredentialcredentialDataCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetCredentialCommandParams.put("userIndex",doorLocksetCredentialuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); - doorLocksetCredentialCommandParams.put("userStatus",doorLocksetCredentialuserStatusCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); - doorLocksetCredentialCommandParams.put("userType",doorLocksetCredentialuserTypeCommandParameterInfo); - - InteractionInfo doorLocksetCredentialInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setCredential((ChipClusters.DoorLockCluster.SetCredentialResponseCallback) callback - , (Integer) - commandArguments.get("operationType") - , (ChipStructs.DoorLockClusterDlCredential) - commandArguments.get("credential") - , (byte[]) - commandArguments.get("credentialData") - , (Integer) - commandArguments.get("userIndex") - , (Integer) - commandArguments.get("userStatus") - , (Integer) - commandArguments.get("userType") - , 10000 - ); - }, - () -> new DelegatedSetCredentialResponseCallback(), - doorLocksetCredentialCommandParams - ); - doorLockClusterInteractionInfoMap.put("setCredential", doorLocksetCredentialInteractionInfo); - Map doorLocksetUserCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); - doorLocksetUserCommandParams.put("operationType",doorLocksetUseroperationTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetUserCommandParams.put("userIndex",doorLocksetUseruserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = new CommandParameterInfo("userName", String.class); - doorLocksetUserCommandParams.put("userName",doorLocksetUseruserNameCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = new CommandParameterInfo("userUniqueId", Long.class); - doorLocksetUserCommandParams.put("userUniqueId",doorLocksetUseruserUniqueIdCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); - doorLocksetUserCommandParams.put("userStatus",doorLocksetUseruserStatusCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); - doorLocksetUserCommandParams.put("userType",doorLocksetUseruserTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = new CommandParameterInfo("credentialRule", Integer.class); - doorLocksetUserCommandParams.put("credentialRule",doorLocksetUsercredentialRuleCommandParameterInfo); - - InteractionInfo doorLocksetUserInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setUser((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("operationType") - , (Integer) - commandArguments.get("userIndex") - , (String) - commandArguments.get("userName") - , (Long) - commandArguments.get("userUniqueId") - , (Integer) - commandArguments.get("userStatus") - , (Integer) - commandArguments.get("userType") - , (Integer) - commandArguments.get("credentialRule") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetUserCommandParams - ); - doorLockClusterInteractionInfoMap.put("setUser", doorLocksetUserInteractionInfo); - Map doorLocksetWeekDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("weekDayIndex",doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("userIndex",doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = new CommandParameterInfo("daysMask", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("daysMask",doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = new CommandParameterInfo("startHour", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("startHour",doorLocksetWeekDaySchedulestartHourCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = new CommandParameterInfo("startMinute", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("startMinute",doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = new CommandParameterInfo("endHour", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("endHour",doorLocksetWeekDayScheduleendHourCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = new CommandParameterInfo("endMinute", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("endMinute",doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); - - InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setWeekDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("weekDayIndex") - , (Integer) - commandArguments.get("userIndex") - , (Integer) - commandArguments.get("daysMask") - , (Integer) - commandArguments.get("startHour") - , (Integer) - commandArguments.get("startMinute") - , (Integer) - commandArguments.get("endHour") - , (Integer) - commandArguments.get("endMinute") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetWeekDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("setWeekDaySchedule", doorLocksetWeekDayScheduleInteractionInfo); - Map doorLocksetYearDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); - doorLocksetYearDayScheduleCommandParams.put("yearDayIndex",doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetYearDayScheduleCommandParams.put("userIndex",doorLocksetYearDayScheduleuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = new CommandParameterInfo("localStartTime", Long.class); - doorLocksetYearDayScheduleCommandParams.put("localStartTime",doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = new CommandParameterInfo("localEndTime", Long.class); - doorLocksetYearDayScheduleCommandParams.put("localEndTime",doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); - - InteractionInfo doorLocksetYearDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setYearDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("yearDayIndex") - , (Integer) - commandArguments.get("userIndex") - , (Long) - commandArguments.get("localStartTime") - , (Long) - commandArguments.get("localEndTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetYearDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("setYearDaySchedule", doorLocksetYearDayScheduleInteractionInfo); - Map doorLockunlockDoorCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); - doorLockunlockDoorCommandParams.put("pinCode",doorLockunlockDoorpinCodeCommandParameterInfo); - - InteractionInfo doorLockunlockDoorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .unlockDoor((DefaultClusterCallback) callback - , (Optional) - commandArguments.get("pinCode") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockunlockDoorCommandParams - ); - doorLockClusterInteractionInfoMap.put("unlockDoor", doorLockunlockDoorInteractionInfo); - Map doorLockunlockWithTimeoutCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = new CommandParameterInfo("timeout", Integer.class); - doorLockunlockWithTimeoutCommandParams.put("timeout",doorLockunlockWithTimeouttimeoutCommandParameterInfo); - - CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); - doorLockunlockWithTimeoutCommandParams.put("pinCode",doorLockunlockWithTimeoutpinCodeCommandParameterInfo); - - InteractionInfo doorLockunlockWithTimeoutInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .unlockWithTimeout((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("timeout") - , (Optional) - commandArguments.get("pinCode") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockunlockWithTimeoutCommandParams - ); - doorLockClusterInteractionInfoMap.put("unlockWithTimeout", doorLockunlockWithTimeoutInteractionInfo); - commandMap.put("doorLock", doorLockClusterInteractionInfoMap); - Map electricalMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("electricalMeasurement", electricalMeasurementClusterInteractionInfoMap); - Map ethernetNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map ethernetNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); - InteractionInfo ethernetNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - ethernetNetworkDiagnosticsresetCountsCommandParams - ); - ethernetNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", ethernetNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); - Map fixedLabelClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("fixedLabel", fixedLabelClusterInteractionInfoMap); - Map flowMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("flowMeasurement", flowMeasurementClusterInteractionInfoMap); - Map generalCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); - Map generalCommissioningarmFailSafeCommandParams = new LinkedHashMap(); - CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = new CommandParameterInfo("expiryLengthSeconds", Integer.class); - generalCommissioningarmFailSafeCommandParams.put("expiryLengthSeconds",generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); - - CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - generalCommissioningarmFailSafeCommandParams.put("breadcrumb",generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); - - CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); - generalCommissioningarmFailSafeCommandParams.put("timeoutMs",generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); - - InteractionInfo generalCommissioningarmFailSafeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .armFailSafe((ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback) callback - , (Integer) - commandArguments.get("expiryLengthSeconds") - , (Long) - commandArguments.get("breadcrumb") - , (Long) - commandArguments.get("timeoutMs") - - ); - }, - () -> new DelegatedArmFailSafeResponseCallback(), - generalCommissioningarmFailSafeCommandParams - ); - generalCommissioningClusterInteractionInfoMap.put("armFailSafe", generalCommissioningarmFailSafeInteractionInfo); - Map generalCommissioningcommissioningCompleteCommandParams = new LinkedHashMap(); - InteractionInfo generalCommissioningcommissioningCompleteInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .commissioningComplete((ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback) callback - - ); - }, - () -> new DelegatedCommissioningCompleteResponseCallback(), - generalCommissioningcommissioningCompleteCommandParams - ); - generalCommissioningClusterInteractionInfoMap.put("commissioningComplete", generalCommissioningcommissioningCompleteInteractionInfo); - Map generalCommissioningsetRegulatoryConfigCommandParams = new LinkedHashMap(); - CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = new CommandParameterInfo("location", Integer.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("location",generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = new CommandParameterInfo("countryCode", String.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("countryCode",generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("breadcrumb",generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("timeoutMs",generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); - - InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .setRegulatoryConfig((ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback) callback - , (Integer) - commandArguments.get("location") - , (String) - commandArguments.get("countryCode") - , (Long) - commandArguments.get("breadcrumb") - , (Long) - commandArguments.get("timeoutMs") - - ); - }, - () -> new DelegatedSetRegulatoryConfigResponseCallback(), - generalCommissioningsetRegulatoryConfigCommandParams - ); - generalCommissioningClusterInteractionInfoMap.put("setRegulatoryConfig", generalCommissioningsetRegulatoryConfigInteractionInfo); - commandMap.put("generalCommissioning", generalCommissioningClusterInteractionInfoMap); - Map generalDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("generalDiagnostics", generalDiagnosticsClusterInteractionInfoMap); - Map groupKeyManagementClusterInteractionInfoMap = new LinkedHashMap<>(); - Map groupKeyManagementkeySetReadCommandParams = new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); - groupKeyManagementkeySetReadCommandParams.put("groupKeySetID",groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetReadInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetRead((ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback - , (Integer) - commandArguments.get("groupKeySetID") - - ); - }, - () -> new DelegatedKeySetReadResponseCallback(), - groupKeyManagementkeySetReadCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetRead", groupKeyManagementkeySetReadInteractionInfo); - Map groupKeyManagementkeySetReadAllIndicesCommandParams = new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = new CommandParameterInfo("groupKeySetIDs", ArrayList.class); - groupKeyManagementkeySetReadAllIndicesCommandParams.put("groupKeySetIDs",groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetReadAllIndices((ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) callback - , (ArrayList) - commandArguments.get("groupKeySetIDs") - - ); - }, - () -> new DelegatedKeySetReadAllIndicesResponseCallback(), - groupKeyManagementkeySetReadAllIndicesCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetReadAllIndices", groupKeyManagementkeySetReadAllIndicesInteractionInfo); - Map groupKeyManagementkeySetRemoveCommandParams = new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); - groupKeyManagementkeySetRemoveCommandParams.put("groupKeySetID",groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetRemove((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("groupKeySetID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupKeyManagementkeySetRemoveCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetRemove", groupKeyManagementkeySetRemoveInteractionInfo); - Map groupKeyManagementkeySetWriteCommandParams = new LinkedHashMap(); - InteractionInfo groupKeyManagementkeySetWriteInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetWrite((DefaultClusterCallback) callback - , (ChipStructs.GroupKeyManagementClusterGroupKeySet) - commandArguments.get("groupKeySet") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupKeyManagementkeySetWriteCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetWrite", groupKeyManagementkeySetWriteInteractionInfo); - commandMap.put("groupKeyManagement", groupKeyManagementClusterInteractionInfoMap); - Map groupsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map groupsaddGroupCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsaddGroupCommandParams.put("groupId",groupsaddGroupgroupIdCommandParameterInfo); - - CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); - groupsaddGroupCommandParams.put("groupName",groupsaddGroupgroupNameCommandParameterInfo); - - InteractionInfo groupsaddGroupInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .addGroup((ChipClusters.GroupsCluster.AddGroupResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (String) - commandArguments.get("groupName") - - ); - }, - () -> new DelegatedAddGroupResponseCallback(), - groupsaddGroupCommandParams - ); - groupsClusterInteractionInfoMap.put("addGroup", groupsaddGroupInteractionInfo); - Map groupsaddGroupIfIdentifyingCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsaddGroupIfIdentifyingCommandParams.put("groupId",groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); - - CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); - groupsaddGroupIfIdentifyingCommandParams.put("groupName",groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); - - InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .addGroupIfIdentifying((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("groupId") - , (String) - commandArguments.get("groupName") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupsaddGroupIfIdentifyingCommandParams - ); - groupsClusterInteractionInfoMap.put("addGroupIfIdentifying", groupsaddGroupIfIdentifyingInteractionInfo); - Map groupsgetGroupMembershipCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = new CommandParameterInfo("groupList", ArrayList.class); - groupsgetGroupMembershipCommandParams.put("groupList",groupsgetGroupMembershipgroupListCommandParameterInfo); - - InteractionInfo groupsgetGroupMembershipInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .getGroupMembership((ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback - , (ArrayList) - commandArguments.get("groupList") - - ); - }, - () -> new DelegatedGetGroupMembershipResponseCallback(), - groupsgetGroupMembershipCommandParams - ); - groupsClusterInteractionInfoMap.put("getGroupMembership", groupsgetGroupMembershipInteractionInfo); - Map groupsremoveAllGroupsCommandParams = new LinkedHashMap(); - InteractionInfo groupsremoveAllGroupsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .removeAllGroups((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupsremoveAllGroupsCommandParams - ); - groupsClusterInteractionInfoMap.put("removeAllGroups", groupsremoveAllGroupsInteractionInfo); - Map groupsremoveGroupCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsremoveGroupCommandParams.put("groupId",groupsremoveGroupgroupIdCommandParameterInfo); - - InteractionInfo groupsremoveGroupInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .removeGroup((ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedRemoveGroupResponseCallback(), - groupsremoveGroupCommandParams - ); - groupsClusterInteractionInfoMap.put("removeGroup", groupsremoveGroupInteractionInfo); - Map groupsviewGroupCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsviewGroupCommandParams.put("groupId",groupsviewGroupgroupIdCommandParameterInfo); - - InteractionInfo groupsviewGroupInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .viewGroup((ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedViewGroupResponseCallback(), - groupsviewGroupCommandParams - ); - groupsClusterInteractionInfoMap.put("viewGroup", groupsviewGroupInteractionInfo); - commandMap.put("groups", groupsClusterInteractionInfoMap); - Map identifyClusterInteractionInfoMap = new LinkedHashMap<>(); - Map identifyidentifyCommandParams = new LinkedHashMap(); - CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("identifyTime", Integer.class); - identifyidentifyCommandParams.put("identifyTime",identifyidentifyidentifyTimeCommandParameterInfo); - - InteractionInfo identifyidentifyInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .identify((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("identifyTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - identifyidentifyCommandParams - ); - identifyClusterInteractionInfoMap.put("identify", identifyidentifyInteractionInfo); - Map identifyidentifyQueryCommandParams = new LinkedHashMap(); - InteractionInfo identifyidentifyQueryInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .identifyQuery((ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback - - ); - }, - () -> new DelegatedIdentifyQueryResponseCallback(), - identifyidentifyQueryCommandParams - ); - identifyClusterInteractionInfoMap.put("identifyQuery", identifyidentifyQueryInteractionInfo); - Map identifytriggerEffectCommandParams = new LinkedHashMap(); - CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = new CommandParameterInfo("effectIdentifier", Integer.class); - identifytriggerEffectCommandParams.put("effectIdentifier",identifytriggerEffecteffectIdentifierCommandParameterInfo); - - CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); - identifytriggerEffectCommandParams.put("effectVariant",identifytriggerEffecteffectVariantCommandParameterInfo); - - InteractionInfo identifytriggerEffectInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .triggerEffect((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("effectIdentifier") - , (Integer) - commandArguments.get("effectVariant") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - identifytriggerEffectCommandParams - ); - identifyClusterInteractionInfoMap.put("triggerEffect", identifytriggerEffectInteractionInfo); - commandMap.put("identify", identifyClusterInteractionInfoMap); - Map illuminanceMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInteractionInfoMap); - Map keypadInputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map keypadInputsendKeyRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = new CommandParameterInfo("keyCode", Integer.class); - keypadInputsendKeyRequestCommandParams.put("keyCode",keypadInputsendKeyRequestkeyCodeCommandParameterInfo); - - InteractionInfo keypadInputsendKeyRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .sendKeyRequest((ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback - , (Integer) - commandArguments.get("keyCode") - - ); - }, - () -> new DelegatedSendKeyResponseCallback(), - keypadInputsendKeyRequestCommandParams - ); - keypadInputClusterInteractionInfoMap.put("sendKeyRequest", keypadInputsendKeyRequestInteractionInfo); - commandMap.put("keypadInput", keypadInputClusterInteractionInfoMap); - Map levelControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map levelControlmoveCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - levelControlmoveCommandParams.put("moveMode",levelControlmovemoveModeCommandParameterInfo); - - CommandParameterInfo levelControlmoverateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - levelControlmoveCommandParams.put("rate",levelControlmoverateCommandParameterInfo); - - CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlmoveCommandParams.put("optionMask",levelControlmoveoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlmoveCommandParams.put("optionOverride",levelControlmoveoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlmoveInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .move((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveCommandParams - ); - levelControlClusterInteractionInfoMap.put("move", levelControlmoveInteractionInfo); - Map levelControlmoveToLevelCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); - levelControlmoveToLevelCommandParams.put("level",levelControlmoveToLevellevelCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlmoveToLevelCommandParams.put("transitionTime",levelControlmoveToLeveltransitionTimeCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlmoveToLevelCommandParams.put("optionMask",levelControlmoveToLeveloptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlmoveToLevelCommandParams.put("optionOverride",levelControlmoveToLeveloptionOverrideCommandParameterInfo); - - InteractionInfo levelControlmoveToLevelInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveToLevel((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("level") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveToLevelCommandParams - ); - levelControlClusterInteractionInfoMap.put("moveToLevel", levelControlmoveToLevelInteractionInfo); - Map levelControlmoveToLevelWithOnOffCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); - levelControlmoveToLevelWithOnOffCommandParams.put("level",levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlmoveToLevelWithOnOffCommandParams.put("transitionTime",levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); - - InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveToLevelWithOnOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("level") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveToLevelWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffInteractionInfo); - Map levelControlmoveWithOnOffCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - levelControlmoveWithOnOffCommandParams.put("moveMode",levelControlmoveWithOnOffmoveModeCommandParameterInfo); - - CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - levelControlmoveWithOnOffCommandParams.put("rate",levelControlmoveWithOnOffrateCommandParameterInfo); - - InteractionInfo levelControlmoveWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveWithOnOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("moveWithOnOff", levelControlmoveWithOnOffInteractionInfo); - Map levelControlstepCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlstepstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - levelControlstepCommandParams.put("stepMode",levelControlstepstepModeCommandParameterInfo); - - CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - levelControlstepCommandParams.put("stepSize",levelControlstepstepSizeCommandParameterInfo); - - CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlstepCommandParams.put("transitionTime",levelControlsteptransitionTimeCommandParameterInfo); - - CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlstepCommandParams.put("optionMask",levelControlstepoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlstepCommandParams.put("optionOverride",levelControlstepoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlstepInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .step((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstepCommandParams - ); - levelControlClusterInteractionInfoMap.put("step", levelControlstepInteractionInfo); - Map levelControlstepWithOnOffCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - levelControlstepWithOnOffCommandParams.put("stepMode",levelControlstepWithOnOffstepModeCommandParameterInfo); - - CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - levelControlstepWithOnOffCommandParams.put("stepSize",levelControlstepWithOnOffstepSizeCommandParameterInfo); - - CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlstepWithOnOffCommandParams.put("transitionTime",levelControlstepWithOnOfftransitionTimeCommandParameterInfo); - - InteractionInfo levelControlstepWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stepWithOnOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstepWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("stepWithOnOff", levelControlstepWithOnOffInteractionInfo); - Map levelControlstopCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlstopCommandParams.put("optionMask",levelControlstopoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlstopCommandParams.put("optionOverride",levelControlstopoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlstopInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stop((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstopCommandParams - ); - levelControlClusterInteractionInfoMap.put("stop", levelControlstopInteractionInfo); - Map levelControlstopWithOnOffCommandParams = new LinkedHashMap(); - InteractionInfo levelControlstopWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stopWithOnOff((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstopWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("stopWithOnOff", levelControlstopWithOnOffInteractionInfo); - commandMap.put("levelControl", levelControlClusterInteractionInfoMap); - Map localizationConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("localizationConfiguration", localizationConfigurationClusterInteractionInfoMap); - Map lowPowerClusterInteractionInfoMap = new LinkedHashMap<>(); - Map lowPowersleepCommandParams = new LinkedHashMap(); - InteractionInfo lowPowersleepInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .sleep((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - lowPowersleepCommandParams - ); - lowPowerClusterInteractionInfoMap.put("sleep", lowPowersleepInteractionInfo); - commandMap.put("lowPower", lowPowerClusterInteractionInfoMap); - Map mediaInputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map mediaInputhideInputStatusRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaInputhideInputStatusRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .hideInputStatusRequest((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputhideInputStatusRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("hideInputStatusRequest", mediaInputhideInputStatusRequestInteractionInfo); - Map mediaInputrenameInputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - mediaInputrenameInputRequestCommandParams.put("index",mediaInputrenameInputRequestindexCommandParameterInfo); - - CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); - mediaInputrenameInputRequestCommandParams.put("name",mediaInputrenameInputRequestnameCommandParameterInfo); - - InteractionInfo mediaInputrenameInputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .renameInputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - , (String) - commandArguments.get("name") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputrenameInputRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("renameInputRequest", mediaInputrenameInputRequestInteractionInfo); - Map mediaInputselectInputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - mediaInputselectInputRequestCommandParams.put("index",mediaInputselectInputRequestindexCommandParameterInfo); - - InteractionInfo mediaInputselectInputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .selectInputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputselectInputRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("selectInputRequest", mediaInputselectInputRequestInteractionInfo); - Map mediaInputshowInputStatusRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaInputshowInputStatusRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .showInputStatusRequest((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputshowInputStatusRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("showInputStatusRequest", mediaInputshowInputStatusRequestInteractionInfo); - commandMap.put("mediaInput", mediaInputClusterInteractionInfoMap); - Map mediaPlaybackClusterInteractionInfoMap = new LinkedHashMap<>(); - Map mediaPlaybackfastForwardRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackfastForwardRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .fastForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackfastForwardRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("fastForwardRequest", mediaPlaybackfastForwardRequestInteractionInfo); - Map mediaPlaybacknextRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybacknextRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .nextRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybacknextRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("nextRequest", mediaPlaybacknextRequestInteractionInfo); - Map mediaPlaybackpauseRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackpauseRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .pauseRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackpauseRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("pauseRequest", mediaPlaybackpauseRequestInteractionInfo); - Map mediaPlaybackplayRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackplayRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .playRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackplayRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("playRequest", mediaPlaybackplayRequestInteractionInfo); - Map mediaPlaybackpreviousRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackpreviousRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .previousRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackpreviousRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("previousRequest", mediaPlaybackpreviousRequestInteractionInfo); - Map mediaPlaybackrewindRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackrewindRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .rewindRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackrewindRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("rewindRequest", mediaPlaybackrewindRequestInteractionInfo); - Map mediaPlaybackseekRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = new CommandParameterInfo("position", Long.class); - mediaPlaybackseekRequestCommandParams.put("position",mediaPlaybackseekRequestpositionCommandParameterInfo); - - InteractionInfo mediaPlaybackseekRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .seekRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - , (Long) - commandArguments.get("position") - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackseekRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("seekRequest", mediaPlaybackseekRequestInteractionInfo); - Map mediaPlaybackskipBackwardRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); - mediaPlaybackskipBackwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); - - InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .skipBackwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - , (Long) - commandArguments.get("deltaPositionMilliseconds") - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackskipBackwardRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("skipBackwardRequest", mediaPlaybackskipBackwardRequestInteractionInfo); - Map mediaPlaybackskipForwardRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); - mediaPlaybackskipForwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); - - InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .skipForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - , (Long) - commandArguments.get("deltaPositionMilliseconds") - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackskipForwardRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("skipForwardRequest", mediaPlaybackskipForwardRequestInteractionInfo); - Map mediaPlaybackstartOverRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackstartOverRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .startOverRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackstartOverRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("startOverRequest", mediaPlaybackstartOverRequestInteractionInfo); - Map mediaPlaybackstopRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackstopRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .stopRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackstopRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("stopRequest", mediaPlaybackstopRequestInteractionInfo); - commandMap.put("mediaPlayback", mediaPlaybackClusterInteractionInfoMap); - Map modeSelectClusterInteractionInfoMap = new LinkedHashMap<>(); - Map modeSelectchangeToModeCommandParams = new LinkedHashMap(); - CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = new CommandParameterInfo("newMode", Integer.class); - modeSelectchangeToModeCommandParams.put("newMode",modeSelectchangeToModenewModeCommandParameterInfo); - - InteractionInfo modeSelectchangeToModeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .changeToMode((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("newMode") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - modeSelectchangeToModeCommandParams - ); - modeSelectClusterInteractionInfoMap.put("changeToMode", modeSelectchangeToModeInteractionInfo); - commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); - Map networkCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); - Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = new CommandParameterInfo("operationalDataset", byte[].class); - networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("operationalDataset",networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .addOrUpdateThreadNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("operationalDataset") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningaddOrUpdateThreadNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("addOrUpdateThreadNetwork", networkCommissioningaddOrUpdateThreadNetworkInteractionInfo); - Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("ssid",networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = new CommandParameterInfo("credentials", byte[].class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("credentials",networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .addOrUpdateWiFiNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("ssid") - , (byte[]) - commandArguments.get("credentials") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningaddOrUpdateWiFiNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("addOrUpdateWiFiNetwork", networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo); - Map networkCommissioningconnectNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); - networkCommissioningconnectNetworkCommandParams.put("networkID",networkCommissioningconnectNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningconnectNetworkCommandParams.put("breadcrumb",networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningconnectNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .connectNetwork((ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback) callback - , (byte[]) - commandArguments.get("networkID") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedConnectNetworkResponseCallback(), - networkCommissioningconnectNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("connectNetwork", networkCommissioningconnectNetworkInteractionInfo); - Map networkCommissioningremoveNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); - networkCommissioningremoveNetworkCommandParams.put("networkID",networkCommissioningremoveNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningremoveNetworkCommandParams.put("breadcrumb",networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningremoveNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .removeNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("networkID") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningremoveNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("removeNetwork", networkCommissioningremoveNetworkInteractionInfo); - Map networkCommissioningreorderNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); - networkCommissioningreorderNetworkCommandParams.put("networkID",networkCommissioningreorderNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = new CommandParameterInfo("networkIndex", Integer.class); - networkCommissioningreorderNetworkCommandParams.put("networkIndex",networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); - - CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningreorderNetworkCommandParams.put("breadcrumb",networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningreorderNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .reorderNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("networkID") - , (Integer) - commandArguments.get("networkIndex") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningreorderNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("reorderNetwork", networkCommissioningreorderNetworkInteractionInfo); - Map networkCommissioningscanNetworksCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); - networkCommissioningscanNetworksCommandParams.put("ssid",networkCommissioningscanNetworksssidCommandParameterInfo); - - CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningscanNetworksCommandParams.put("breadcrumb",networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningscanNetworksInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .scanNetworks((ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback) callback - , (byte[]) - commandArguments.get("ssid") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedScanNetworksResponseCallback(), - networkCommissioningscanNetworksCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("scanNetworks", networkCommissioningscanNetworksInteractionInfo); - commandMap.put("networkCommissioning", networkCommissioningClusterInteractionInfoMap); - Map otaSoftwareUpdateProviderClusterInteractionInfoMap = new LinkedHashMap<>(); - Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("updateToken",otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = new CommandParameterInfo("newVersion", Long.class); - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("newVersion",otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .applyUpdateRequest((ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback) callback - , (byte[]) - commandArguments.get("updateToken") - , (Long) - commandArguments.get("newVersion") - - ); - }, - () -> new DelegatedApplyUpdateResponseCallback(), - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams - ); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put("applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo); - Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("updateToken",otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("softwareVersion",otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .notifyUpdateApplied((DefaultClusterCallback) callback - , (byte[]) - commandArguments.get("updateToken") - , (Long) - commandArguments.get("softwareVersion") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams - ); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put("notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo); - Map otaSoftwareUpdateProviderqueryImageCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("vendorId",otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = new CommandParameterInfo("productId", Integer.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("productId",otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("softwareVersion",otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = new CommandParameterInfo("protocolsSupported", ArrayList.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("protocolsSupported",otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = new CommandParameterInfo("hardwareVersion", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("hardwareVersion",otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = new CommandParameterInfo("location", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("location",otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = new CommandParameterInfo("requestorCanConsent", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("requestorCanConsent",otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = new CommandParameterInfo("metadataForProvider", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("metadataForProvider",otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .queryImage((ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback) callback - , (Integer) - commandArguments.get("vendorId") - , (Integer) - commandArguments.get("productId") - , (Long) - commandArguments.get("softwareVersion") - , (ArrayList) - commandArguments.get("protocolsSupported") - , (Optional) - commandArguments.get("hardwareVersion") - , (Optional) - commandArguments.get("location") - , (Optional) - commandArguments.get("requestorCanConsent") - , (Optional) - commandArguments.get("metadataForProvider") - - ); - }, - () -> new DelegatedQueryImageResponseCallback(), - otaSoftwareUpdateProviderqueryImageCommandParams - ); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put("queryImage", otaSoftwareUpdateProviderqueryImageInteractionInfo); - commandMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInteractionInfoMap); - Map otaSoftwareUpdateRequestorClusterInteractionInfoMap = new LinkedHashMap<>(); - Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = new CommandParameterInfo("providerNodeId", Long.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("providerNodeId",otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("vendorId",otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = new CommandParameterInfo("announcementReason", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("announcementReason",otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = new CommandParameterInfo("metadataForNode", Optional.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("metadataForNode",otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = new CommandParameterInfo("endpoint", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("endpoint",otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .announceOtaProvider((DefaultClusterCallback) callback - , (Long) - commandArguments.get("providerNodeId") - , (Integer) - commandArguments.get("vendorId") - , (Integer) - commandArguments.get("announcementReason") - , (Optional) - commandArguments.get("metadataForNode") - , (Integer) - commandArguments.get("endpoint") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams - ); - otaSoftwareUpdateRequestorClusterInteractionInfoMap.put("announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo); - commandMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInteractionInfoMap); - Map occupancySensingClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("occupancySensing", occupancySensingClusterInteractionInfoMap); - Map onOffClusterInteractionInfoMap = new LinkedHashMap<>(); - Map onOffoffCommandParams = new LinkedHashMap(); - InteractionInfo onOffoffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .off((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffoffCommandParams - ); - onOffClusterInteractionInfoMap.put("off", onOffoffInteractionInfo); - Map onOffoffWithEffectCommandParams = new LinkedHashMap(); - CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = new CommandParameterInfo("effectId", Integer.class); - onOffoffWithEffectCommandParams.put("effectId",onOffoffWithEffecteffectIdCommandParameterInfo); - - CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); - onOffoffWithEffectCommandParams.put("effectVariant",onOffoffWithEffecteffectVariantCommandParameterInfo); - - InteractionInfo onOffoffWithEffectInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .offWithEffect((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("effectId") - , (Integer) - commandArguments.get("effectVariant") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffoffWithEffectCommandParams - ); - onOffClusterInteractionInfoMap.put("offWithEffect", onOffoffWithEffectInteractionInfo); - Map onOffonCommandParams = new LinkedHashMap(); - InteractionInfo onOffonInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .on((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonCommandParams - ); - onOffClusterInteractionInfoMap.put("on", onOffonInteractionInfo); - Map onOffonWithRecallGlobalSceneCommandParams = new LinkedHashMap(); - InteractionInfo onOffonWithRecallGlobalSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .onWithRecallGlobalScene((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonWithRecallGlobalSceneCommandParams - ); - onOffClusterInteractionInfoMap.put("onWithRecallGlobalScene", onOffonWithRecallGlobalSceneInteractionInfo); - Map onOffonWithTimedOffCommandParams = new LinkedHashMap(); - CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = new CommandParameterInfo("onOffControl", Integer.class); - onOffonWithTimedOffCommandParams.put("onOffControl",onOffonWithTimedOffonOffControlCommandParameterInfo); - - CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = new CommandParameterInfo("onTime", Integer.class); - onOffonWithTimedOffCommandParams.put("onTime",onOffonWithTimedOffonTimeCommandParameterInfo); - - CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("offWaitTime", Integer.class); - onOffonWithTimedOffCommandParams.put("offWaitTime",onOffonWithTimedOffoffWaitTimeCommandParameterInfo); - - InteractionInfo onOffonWithTimedOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .onWithTimedOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("onOffControl") - , (Integer) - commandArguments.get("onTime") - , (Integer) - commandArguments.get("offWaitTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonWithTimedOffCommandParams - ); - onOffClusterInteractionInfoMap.put("onWithTimedOff", onOffonWithTimedOffInteractionInfo); - Map onOfftoggleCommandParams = new LinkedHashMap(); - InteractionInfo onOfftoggleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .toggle((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOfftoggleCommandParams - ); - onOffClusterInteractionInfoMap.put("toggle", onOfftoggleInteractionInfo); - commandMap.put("onOff", onOffClusterInteractionInfoMap); - Map onOffSwitchConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInteractionInfoMap); - Map operationalCredentialsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map operationalCredentialsaddNOCCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); - operationalCredentialsaddNOCCommandParams.put("NOCValue",operationalCredentialsaddNOCNOCValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); - operationalCredentialsaddNOCCommandParams.put("ICACValue",operationalCredentialsaddNOCICACValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = new CommandParameterInfo("IPKValue", byte[].class); - operationalCredentialsaddNOCCommandParams.put("IPKValue",operationalCredentialsaddNOCIPKValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = new CommandParameterInfo("caseAdminNode", Long.class); - operationalCredentialsaddNOCCommandParams.put("caseAdminNode",operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = new CommandParameterInfo("adminVendorId", Integer.class); - operationalCredentialsaddNOCCommandParams.put("adminVendorId",operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); - - InteractionInfo operationalCredentialsaddNOCInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .addNOC((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (byte[]) - commandArguments.get("NOCValue") - , (Optional) - commandArguments.get("ICACValue") - , (byte[]) - commandArguments.get("IPKValue") - , (Long) - commandArguments.get("caseAdminNode") - , (Integer) - commandArguments.get("adminVendorId") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsaddNOCCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("addNOC", operationalCredentialsaddNOCInteractionInfo); - Map operationalCredentialsaddTrustedRootCertificateCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = new CommandParameterInfo("rootCertificate", byte[].class); - operationalCredentialsaddTrustedRootCertificateCommandParams.put("rootCertificate",operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); - - InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .addTrustedRootCertificate((DefaultClusterCallback) callback - , (byte[]) - commandArguments.get("rootCertificate") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - operationalCredentialsaddTrustedRootCertificateCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("addTrustedRootCertificate", operationalCredentialsaddTrustedRootCertificateInteractionInfo); - Map operationalCredentialsattestationRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = new CommandParameterInfo("attestationNonce", byte[].class); - operationalCredentialsattestationRequestCommandParams.put("attestationNonce",operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); - - InteractionInfo operationalCredentialsattestationRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .attestationRequest((ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) callback - , (byte[]) - commandArguments.get("attestationNonce") - - ); - }, - () -> new DelegatedAttestationResponseCallback(), - operationalCredentialsattestationRequestCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("attestationRequest", operationalCredentialsattestationRequestInteractionInfo); - Map operationalCredentialscertificateChainRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = new CommandParameterInfo("certificateType", Integer.class); - operationalCredentialscertificateChainRequestCommandParams.put("certificateType",operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); - - InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .certificateChainRequest((ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) callback - , (Integer) - commandArguments.get("certificateType") - - ); - }, - () -> new DelegatedCertificateChainResponseCallback(), - operationalCredentialscertificateChainRequestCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("certificateChainRequest", operationalCredentialscertificateChainRequestInteractionInfo); - Map operationalCredentialsopCSRRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = new CommandParameterInfo("CSRNonce", byte[].class); - operationalCredentialsopCSRRequestCommandParams.put("CSRNonce",operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); - - InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .opCSRRequest((ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback - , (byte[]) - commandArguments.get("CSRNonce") - - ); - }, - () -> new DelegatedOpCSRResponseCallback(), - operationalCredentialsopCSRRequestCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("opCSRRequest", operationalCredentialsopCSRRequestInteractionInfo); - Map operationalCredentialsremoveFabricCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = new CommandParameterInfo("fabricIndex", Integer.class); - operationalCredentialsremoveFabricCommandParams.put("fabricIndex",operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); - - InteractionInfo operationalCredentialsremoveFabricInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .removeFabric((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (Integer) - commandArguments.get("fabricIndex") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsremoveFabricCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("removeFabric", operationalCredentialsremoveFabricInteractionInfo); - Map operationalCredentialsremoveTrustedRootCertificateCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = new CommandParameterInfo("trustedRootIdentifier", byte[].class); - operationalCredentialsremoveTrustedRootCertificateCommandParams.put("trustedRootIdentifier",operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); - - InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .removeTrustedRootCertificate((DefaultClusterCallback) callback - , (byte[]) - commandArguments.get("trustedRootIdentifier") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - operationalCredentialsremoveTrustedRootCertificateCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("removeTrustedRootCertificate", operationalCredentialsremoveTrustedRootCertificateInteractionInfo); - Map operationalCredentialsupdateFabricLabelCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = new CommandParameterInfo("label", String.class); - operationalCredentialsupdateFabricLabelCommandParams.put("label",operationalCredentialsupdateFabricLabellabelCommandParameterInfo); - - InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .updateFabricLabel((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (String) - commandArguments.get("label") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsupdateFabricLabelCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("updateFabricLabel", operationalCredentialsupdateFabricLabelInteractionInfo); - Map operationalCredentialsupdateNOCCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); - operationalCredentialsupdateNOCCommandParams.put("NOCValue",operationalCredentialsupdateNOCNOCValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); - operationalCredentialsupdateNOCCommandParams.put("ICACValue",operationalCredentialsupdateNOCICACValueCommandParameterInfo); - - InteractionInfo operationalCredentialsupdateNOCInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .updateNOC((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (byte[]) - commandArguments.get("NOCValue") - , (Optional) - commandArguments.get("ICACValue") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsupdateNOCCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("updateNOC", operationalCredentialsupdateNOCInteractionInfo); - commandMap.put("operationalCredentials", operationalCredentialsClusterInteractionInfoMap); - Map powerSourceClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("powerSource", powerSourceClusterInteractionInfoMap); - Map powerSourceConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInteractionInfoMap); - Map pressureMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("pressureMeasurement", pressureMeasurementClusterInteractionInfoMap); - Map pumpConfigurationAndControlClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInteractionInfoMap); - Map relativeHumidityMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInteractionInfoMap); - Map scenesClusterInteractionInfoMap = new LinkedHashMap<>(); - Map scenesaddSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesaddSceneCommandParams.put("groupId",scenesaddScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesaddSceneCommandParams.put("sceneId",scenesaddScenesceneIdCommandParameterInfo); - - CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - scenesaddSceneCommandParams.put("transitionTime",scenesaddScenetransitionTimeCommandParameterInfo); - - CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = new CommandParameterInfo("sceneName", String.class); - scenesaddSceneCommandParams.put("sceneName",scenesaddScenesceneNameCommandParameterInfo); - - InteractionInfo scenesaddSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .addScene((ChipClusters.ScenesCluster.AddSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - , (Integer) - commandArguments.get("transitionTime") - , (String) - commandArguments.get("sceneName") - , (ArrayList) - commandArguments.get("extensionFieldSets") - - ); - }, - () -> new DelegatedAddSceneResponseCallback(), - scenesaddSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("addScene", scenesaddSceneInteractionInfo); - Map scenesgetSceneMembershipCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesgetSceneMembershipCommandParams.put("groupId",scenesgetSceneMembershipgroupIdCommandParameterInfo); - - InteractionInfo scenesgetSceneMembershipInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .getSceneMembership((ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedGetSceneMembershipResponseCallback(), - scenesgetSceneMembershipCommandParams - ); - scenesClusterInteractionInfoMap.put("getSceneMembership", scenesgetSceneMembershipInteractionInfo); - Map scenesrecallSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesrecallSceneCommandParams.put("groupId",scenesrecallScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesrecallSceneCommandParams.put("sceneId",scenesrecallScenesceneIdCommandParameterInfo); - - CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - scenesrecallSceneCommandParams.put("transitionTime",scenesrecallScenetransitionTimeCommandParameterInfo); - - InteractionInfo scenesrecallSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .recallScene((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - scenesrecallSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("recallScene", scenesrecallSceneInteractionInfo); - Map scenesremoveAllScenesCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesremoveAllScenesCommandParams.put("groupId",scenesremoveAllScenesgroupIdCommandParameterInfo); - - InteractionInfo scenesremoveAllScenesInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .removeAllScenes((ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedRemoveAllScenesResponseCallback(), - scenesremoveAllScenesCommandParams - ); - scenesClusterInteractionInfoMap.put("removeAllScenes", scenesremoveAllScenesInteractionInfo); - Map scenesremoveSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesremoveSceneCommandParams.put("groupId",scenesremoveScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesremoveSceneCommandParams.put("sceneId",scenesremoveScenesceneIdCommandParameterInfo); - - InteractionInfo scenesremoveSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .removeScene((ChipClusters.ScenesCluster.RemoveSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - - ); - }, - () -> new DelegatedRemoveSceneResponseCallback(), - scenesremoveSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("removeScene", scenesremoveSceneInteractionInfo); - Map scenesstoreSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesstoreSceneCommandParams.put("groupId",scenesstoreScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesstoreSceneCommandParams.put("sceneId",scenesstoreScenesceneIdCommandParameterInfo); - - InteractionInfo scenesstoreSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .storeScene((ChipClusters.ScenesCluster.StoreSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - - ); - }, - () -> new DelegatedStoreSceneResponseCallback(), - scenesstoreSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("storeScene", scenesstoreSceneInteractionInfo); - Map scenesviewSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesviewSceneCommandParams.put("groupId",scenesviewScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesviewSceneCommandParams.put("sceneId",scenesviewScenesceneIdCommandParameterInfo); - - InteractionInfo scenesviewSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .viewScene((ChipClusters.ScenesCluster.ViewSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - - ); - }, - () -> new DelegatedViewSceneResponseCallback(), - scenesviewSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("viewScene", scenesviewSceneInteractionInfo); - commandMap.put("scenes", scenesClusterInteractionInfoMap); - Map softwareDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map softwareDiagnosticsresetWatermarksCommandParams = new LinkedHashMap(); - InteractionInfo softwareDiagnosticsresetWatermarksInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .resetWatermarks((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - softwareDiagnosticsresetWatermarksCommandParams - ); - softwareDiagnosticsClusterInteractionInfoMap.put("resetWatermarks", softwareDiagnosticsresetWatermarksInteractionInfo); - commandMap.put("softwareDiagnostics", softwareDiagnosticsClusterInteractionInfoMap); - Map switchClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("switch", switchClusterInteractionInfoMap); - Map targetNavigatorClusterInteractionInfoMap = new LinkedHashMap<>(); - Map targetNavigatornavigateTargetRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = new CommandParameterInfo("target", Integer.class); - targetNavigatornavigateTargetRequestCommandParams.put("target",targetNavigatornavigateTargetRequesttargetCommandParameterInfo); - - CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); - targetNavigatornavigateTargetRequestCommandParams.put("data",targetNavigatornavigateTargetRequestdataCommandParameterInfo); - - InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .navigateTargetRequest((ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback) callback - , (Integer) - commandArguments.get("target") - , (String) - commandArguments.get("data") - - ); - }, - () -> new DelegatedNavigateTargetResponseCallback(), - targetNavigatornavigateTargetRequestCommandParams - ); - targetNavigatorClusterInteractionInfoMap.put("navigateTargetRequest", targetNavigatornavigateTargetRequestInteractionInfo); - commandMap.put("targetNavigator", targetNavigatorClusterInteractionInfoMap); - Map temperatureMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); - Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); - Map testClustersimpleStructEchoRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustersimpleStructEchoRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .simpleStructEchoRequest((ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback - , (ChipStructs.TestClusterClusterSimpleStruct) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedSimpleStructResponseCallback(), - testClustersimpleStructEchoRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("simpleStructEchoRequest", testClustersimpleStructEchoRequestInteractionInfo); - Map testClustertestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .test((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestCommandParams - ); - testClusterClusterInteractionInfoMap.put("test", testClustertestInteractionInfo); - Map testClustertestAddArgumentsCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); - testClustertestAddArgumentsCommandParams.put("arg1",testClustertestAddArgumentsarg1CommandParameterInfo); - - CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); - testClustertestAddArgumentsCommandParams.put("arg2",testClustertestAddArgumentsarg2CommandParameterInfo); - - InteractionInfo testClustertestAddArgumentsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testAddArguments((ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback) callback - , (Integer) - commandArguments.get("arg1") - , (Integer) - commandArguments.get("arg2") - - ); - }, - () -> new DelegatedTestAddArgumentsResponseCallback(), - testClustertestAddArgumentsCommandParams - ); - testClusterClusterInteractionInfoMap.put("testAddArguments", testClustertestAddArgumentsInteractionInfo); - Map testClustertestEmitTestEventRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); - testClustertestEmitTestEventRequestCommandParams.put("arg1",testClustertestEmitTestEventRequestarg1CommandParameterInfo); - - CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); - testClustertestEmitTestEventRequestCommandParams.put("arg2",testClustertestEmitTestEventRequestarg2CommandParameterInfo); - - CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = new CommandParameterInfo("arg3", Boolean.class); - testClustertestEmitTestEventRequestCommandParams.put("arg3",testClustertestEmitTestEventRequestarg3CommandParameterInfo); - - InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testEmitTestEventRequest((ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback) callback - , (Integer) - commandArguments.get("arg1") - , (Integer) - commandArguments.get("arg2") - , (Boolean) - commandArguments.get("arg3") - - ); - }, - () -> new DelegatedTestEmitTestEventResponseCallback(), - testClustertestEmitTestEventRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testEmitTestEventRequest", testClustertestEmitTestEventRequestInteractionInfo); - Map testClustertestEnumsRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); - testClustertestEnumsRequestCommandParams.put("arg1",testClustertestEnumsRequestarg1CommandParameterInfo); - - CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); - testClustertestEnumsRequestCommandParams.put("arg2",testClustertestEnumsRequestarg2CommandParameterInfo); - - InteractionInfo testClustertestEnumsRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testEnumsRequest((ChipClusters.TestClusterCluster.TestEnumsResponseCallback) callback - , (Integer) - commandArguments.get("arg1") - , (Integer) - commandArguments.get("arg2") - - ); - }, - () -> new DelegatedTestEnumsResponseCallback(), - testClustertestEnumsRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testEnumsRequest", testClustertestEnumsRequestInteractionInfo); - Map testClustertestListInt8UArgumentRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); - testClustertestListInt8UArgumentRequestCommandParams.put("arg1",testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListInt8UArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListInt8UArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestInteractionInfo); - Map testClustertestListInt8UReverseRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); - testClustertestListInt8UReverseRequestCommandParams.put("arg1",testClustertestListInt8UReverseRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListInt8UReverseRequest((ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedTestListInt8UReverseResponseCallback(), - testClustertestListInt8UReverseRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListInt8UReverseRequest", testClustertestListInt8UReverseRequestInteractionInfo); - Map testClustertestListNestedStructListArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestListNestedStructListArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListNestedStructListArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListNestedStructListArgumentRequest", testClustertestListNestedStructListArgumentRequestInteractionInfo); - Map testClustertestListStructArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListStructArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListStructArgumentRequest", testClustertestListStructArgumentRequestInteractionInfo); - Map testClustertestNestedStructArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestNestedStructArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNestedStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ChipStructs.TestClusterClusterNestedStruct) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestNestedStructArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNestedStructArgumentRequest", testClustertestNestedStructArgumentRequestInteractionInfo); - Map testClustertestNestedStructListArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestNestedStructListArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ChipStructs.TestClusterClusterNestedStructList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestNestedStructListArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNestedStructListArgumentRequest", testClustertestNestedStructListArgumentRequestInteractionInfo); - Map testClustertestNotHandledCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestNotHandledInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNotHandled((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestNotHandledCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNotHandled", testClustertestNotHandledInteractionInfo); - Map testClustertestNullableOptionalRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); - testClustertestNullableOptionalRequestCommandParams.put("arg1",testClustertestNullableOptionalRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNullableOptionalRequest((ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) callback - , (Optional) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedTestNullableOptionalResponseCallback(), - testClustertestNullableOptionalRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNullableOptionalRequest", testClustertestNullableOptionalRequestInteractionInfo); - Map testClustertestSimpleOptionalArgumentRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); - testClustertestSimpleOptionalArgumentRequestCommandParams.put("arg1",testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testSimpleOptionalArgumentRequest((DefaultClusterCallback) callback - , (Optional) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestSimpleOptionalArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testSimpleOptionalArgumentRequest", testClustertestSimpleOptionalArgumentRequestInteractionInfo); - Map testClustertestSpecificCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestSpecificInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testSpecific((ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback - - ); - }, - () -> new DelegatedTestSpecificResponseCallback(), - testClustertestSpecificCommandParams - ); - testClusterClusterInteractionInfoMap.put("testSpecific", testClustertestSpecificInteractionInfo); - Map testClustertestStructArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestStructArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ChipStructs.TestClusterClusterSimpleStruct) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestStructArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testStructArgumentRequest", testClustertestStructArgumentRequestInteractionInfo); - Map testClustertestUnknownCommandCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestUnknownCommandInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testUnknownCommand((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestUnknownCommandCommandParams - ); - testClusterClusterInteractionInfoMap.put("testUnknownCommand", testClustertestUnknownCommandInteractionInfo); - Map testClustertimedInvokeRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertimedInvokeRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .timedInvokeRequest((DefaultClusterCallback) callback - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertimedInvokeRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("timedInvokeRequest", testClustertimedInvokeRequestInteractionInfo); - commandMap.put("testCluster", testClusterClusterInteractionInfoMap); - Map thermostatClusterInteractionInfoMap = new LinkedHashMap<>(); - Map thermostatclearWeeklyScheduleCommandParams = new LinkedHashMap(); - InteractionInfo thermostatclearWeeklyScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .clearWeeklySchedule((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatclearWeeklyScheduleCommandParams - ); - thermostatClusterInteractionInfoMap.put("clearWeeklySchedule", thermostatclearWeeklyScheduleInteractionInfo); - Map thermostatgetRelayStatusLogCommandParams = new LinkedHashMap(); - InteractionInfo thermostatgetRelayStatusLogInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .getRelayStatusLog((ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback - - ); - }, - () -> new DelegatedGetRelayStatusLogResponseCallback(), - thermostatgetRelayStatusLogCommandParams - ); - thermostatClusterInteractionInfoMap.put("getRelayStatusLog", thermostatgetRelayStatusLogInteractionInfo); - Map thermostatgetWeeklyScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = new CommandParameterInfo("daysToReturn", Integer.class); - thermostatgetWeeklyScheduleCommandParams.put("daysToReturn",thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); - - CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = new CommandParameterInfo("modeToReturn", Integer.class); - thermostatgetWeeklyScheduleCommandParams.put("modeToReturn",thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); - - InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .getWeeklySchedule((ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback) callback - , (Integer) - commandArguments.get("daysToReturn") - , (Integer) - commandArguments.get("modeToReturn") - - ); - }, - () -> new DelegatedGetWeeklyScheduleResponseCallback(), - thermostatgetWeeklyScheduleCommandParams - ); - thermostatClusterInteractionInfoMap.put("getWeeklySchedule", thermostatgetWeeklyScheduleInteractionInfo); - Map thermostatsetWeeklyScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put("numberOfTransitionsForSequence",thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = new CommandParameterInfo("dayOfWeekForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put("dayOfWeekForSequence",thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = new CommandParameterInfo("modeForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put("modeForSequence",thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = new CommandParameterInfo("payload", ArrayList.class); - thermostatsetWeeklyScheduleCommandParams.put("payload",thermostatsetWeeklySchedulepayloadCommandParameterInfo); - - InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .setWeeklySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("numberOfTransitionsForSequence") - , (Integer) - commandArguments.get("dayOfWeekForSequence") - , (Integer) - commandArguments.get("modeForSequence") - , (ArrayList) - commandArguments.get("payload") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatsetWeeklyScheduleCommandParams - ); - thermostatClusterInteractionInfoMap.put("setWeeklySchedule", thermostatsetWeeklyScheduleInteractionInfo); - Map thermostatsetpointRaiseLowerCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = new CommandParameterInfo("mode", Integer.class); - thermostatsetpointRaiseLowerCommandParams.put("mode",thermostatsetpointRaiseLowermodeCommandParameterInfo); - - CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = new CommandParameterInfo("amount", Integer.class); - thermostatsetpointRaiseLowerCommandParams.put("amount",thermostatsetpointRaiseLoweramountCommandParameterInfo); - - InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .setpointRaiseLower((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("mode") - , (Integer) - commandArguments.get("amount") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatsetpointRaiseLowerCommandParams - ); - thermostatClusterInteractionInfoMap.put("setpointRaiseLower", thermostatsetpointRaiseLowerInteractionInfo); - commandMap.put("thermostat", thermostatClusterInteractionInfoMap); - Map thermostatUserInterfaceConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInteractionInfoMap); - Map threadNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map threadNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); - InteractionInfo threadNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - threadNetworkDiagnosticsresetCountsCommandParams - ); - threadNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", threadNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInteractionInfoMap); - Map timeFormatLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("timeFormatLocalization", timeFormatLocalizationClusterInteractionInfoMap); - Map unitLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("unitLocalization", unitLocalizationClusterInteractionInfoMap); - Map userLabelClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("userLabel", userLabelClusterInteractionInfoMap); - Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); - Map wiFiNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map wiFiNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); - InteractionInfo wiFiNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - wiFiNetworkDiagnosticsresetCountsCommandParams - ); - wiFiNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", wiFiNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInteractionInfoMap); - Map windowCoveringClusterInteractionInfoMap = new LinkedHashMap<>(); - Map windowCoveringdownOrCloseCommandParams = new LinkedHashMap(); - InteractionInfo windowCoveringdownOrCloseInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .downOrClose((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringdownOrCloseCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("downOrClose", windowCoveringdownOrCloseInteractionInfo); - Map windowCoveringgoToLiftPercentageCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = new CommandParameterInfo("liftPercentageValue", Integer.class); - windowCoveringgoToLiftPercentageCommandParams.put("liftPercentageValue",windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); - - CommandParameterInfo windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = new CommandParameterInfo("liftPercent100thsValue", Integer.class); - windowCoveringgoToLiftPercentageCommandParams.put("liftPercent100thsValue",windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToLiftPercentage((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("liftPercentageValue") - , (Integer) - commandArguments.get("liftPercent100thsValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToLiftPercentageCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToLiftPercentage", windowCoveringgoToLiftPercentageInteractionInfo); - Map windowCoveringgoToLiftValueCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = new CommandParameterInfo("liftValue", Integer.class); - windowCoveringgoToLiftValueCommandParams.put("liftValue",windowCoveringgoToLiftValueliftValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToLiftValueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToLiftValue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("liftValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToLiftValueCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToLiftValue", windowCoveringgoToLiftValueInteractionInfo); - Map windowCoveringgoToTiltPercentageCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = new CommandParameterInfo("tiltPercentageValue", Integer.class); - windowCoveringgoToTiltPercentageCommandParams.put("tiltPercentageValue",windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); - - CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = new CommandParameterInfo("tiltPercent100thsValue", Integer.class); - windowCoveringgoToTiltPercentageCommandParams.put("tiltPercent100thsValue",windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToTiltPercentage((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("tiltPercentageValue") - , (Integer) - commandArguments.get("tiltPercent100thsValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToTiltPercentageCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToTiltPercentage", windowCoveringgoToTiltPercentageInteractionInfo); - Map windowCoveringgoToTiltValueCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = new CommandParameterInfo("tiltValue", Integer.class); - windowCoveringgoToTiltValueCommandParams.put("tiltValue",windowCoveringgoToTiltValuetiltValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToTiltValueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToTiltValue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("tiltValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToTiltValueCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToTiltValue", windowCoveringgoToTiltValueInteractionInfo); - Map windowCoveringstopMotionCommandParams = new LinkedHashMap(); - InteractionInfo windowCoveringstopMotionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .stopMotion((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringstopMotionCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("stopMotion", windowCoveringstopMotionInteractionInfo); - Map windowCoveringupOrOpenCommandParams = new LinkedHashMap(); - InteractionInfo windowCoveringupOrOpenInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .upOrOpen((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringupOrOpenCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("upOrOpen", windowCoveringupOrOpenInteractionInfo); - commandMap.put("windowCovering", windowCoveringClusterInteractionInfoMap); - return commandMap; + @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 DelegatedAccessControlClusterExtensionAttributeCallback + implements ChipClusters.AccessControlCluster.ExtensionAttributeCallback, + 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 DelegatedAccessControlClusterAttributeListAttributeCallback + implements ChipClusters.AccessControlCluster.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 DelegatedGetSetupPINResponseCallback + implements ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(String setupPIN) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("setupPIN", "String"); + responseValues.put(setupPINResponseValue, setupPIN); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedAccountLoginClusterAttributeListAttributeCallback + implements ChipClusters.AccountLoginCluster.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 DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback + implements ChipClusters.AdministratorCommissioningCluster.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 DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback + implements ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback, + 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 DelegatedApplicationBasicClusterAttributeListAttributeCallback + implements ChipClusters.ApplicationBasicCluster.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 DelegatedLauncherResponseCallback + implements ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback + implements ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback, + 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 DelegatedApplicationLauncherClusterAttributeListAttributeCallback + implements ChipClusters.ApplicationLauncherCluster.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 DelegatedAudioOutputClusterAudioOutputListAttributeCallback + implements ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback, + 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 DelegatedAudioOutputClusterAttributeListAttributeCallback + implements ChipClusters.AudioOutputCluster.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 DelegatedBarrierControlClusterAttributeListAttributeCallback + implements ChipClusters.BarrierControlCluster.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 DelegatedBasicClusterAttributeListAttributeCallback + implements ChipClusters.BasicCluster.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 DelegatedBinaryInputBasicClusterAttributeListAttributeCallback + implements ChipClusters.BinaryInputBasicCluster.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 DelegatedBindingClusterAttributeListAttributeCallback + implements ChipClusters.BindingCluster.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 DelegatedBooleanStateClusterAttributeListAttributeCallback + implements ChipClusters.BooleanStateCluster.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 DelegatedBridgedActionsClusterActionListAttributeCallback + implements ChipClusters.BridgedActionsCluster.ActionListAttributeCallback, + 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 DelegatedBridgedActionsClusterEndpointListAttributeCallback + implements ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback, + 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 DelegatedBridgedActionsClusterAttributeListAttributeCallback + implements ChipClusters.BridgedActionsCluster.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 DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback + implements ChipClusters.BridgedDeviceBasicCluster.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 DelegatedChangeChannelResponseCallback + implements ChipClusters.ChannelCluster.ChangeChannelResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType) { + Map responseValues = new LinkedHashMap<>(); + // channelMatch: Struct ChannelInfo + // Conversion from this type to Java is not properly implemented yet + CommandResponseInfo errorTypeResponseValue = new CommandResponseInfo("errorType", "Integer"); + responseValues.put(errorTypeResponseValue, errorType); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedChannelClusterChannelListAttributeCallback + implements ChipClusters.ChannelCluster.ChannelListAttributeCallback, + 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 DelegatedChannelClusterAttributeListAttributeCallback + implements ChipClusters.ChannelCluster.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 DelegatedColorControlClusterAttributeListAttributeCallback + implements ChipClusters.ColorControlCluster.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 DelegatedLaunchResponseCallback + implements ChipClusters.ContentLauncherCluster.LaunchResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback + implements ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback, + 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 DelegatedContentLauncherClusterAttributeListAttributeCallback + implements ChipClusters.ContentLauncherCluster.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 DelegatedDescriptorClusterDeviceListAttributeCallback + implements ChipClusters.DescriptorCluster.DeviceListAttributeCallback, + 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 DelegatedDescriptorClusterServerListAttributeCallback + implements ChipClusters.DescriptorCluster.ServerListAttributeCallback, + 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 DelegatedDescriptorClusterClientListAttributeCallback + implements ChipClusters.DescriptorCluster.ClientListAttributeCallback, + 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 DelegatedDescriptorClusterPartsListAttributeCallback + implements ChipClusters.DescriptorCluster.PartsListAttributeCallback, + 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 DelegatedDescriptorClusterAttributeListAttributeCallback + implements ChipClusters.DescriptorCluster.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 DelegatedRetrieveLogsResponseCallback + implements ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo contentResponseValue = new CommandResponseInfo("content", "byte[]"); + responseValues.put(contentResponseValue, content); + CommandResponseInfo timeStampResponseValue = new CommandResponseInfo("timeStamp", "Long"); + responseValues.put(timeStampResponseValue, timeStamp); + CommandResponseInfo timeSinceBootResponseValue = + new CommandResponseInfo("timeSinceBoot", "Long"); + responseValues.put(timeSinceBootResponseValue, timeSinceBoot); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedDiagnosticLogsClusterAttributeListAttributeCallback + implements ChipClusters.DiagnosticLogsCluster.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 DelegatedGetCredentialStatusResponseCallback + implements ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Boolean credentialExists, + @Nullable Integer userIndex, + @Nullable Integer nextCredentialIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo credentialExistsResponseValue = + new CommandResponseInfo("credentialExists", "Boolean"); + responseValues.put(credentialExistsResponseValue, credentialExists); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo nextCredentialIndexResponseValue = + new CommandResponseInfo("nextCredentialIndex", "Integer"); + responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetUserResponseCallback + implements ChipClusters.DoorLockCluster.GetUserResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + @Nullable ArrayList credentials, + @Nullable Integer creatorFabricIndex, + @Nullable Integer lastModifiedFabricIndex, + @Nullable Integer nextUserIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo userNameResponseValue = new CommandResponseInfo("userName", "String"); + responseValues.put(userNameResponseValue, userName); + CommandResponseInfo userUniqueIdResponseValue = + new CommandResponseInfo("userUniqueId", "Long"); + responseValues.put(userUniqueIdResponseValue, userUniqueId); + CommandResponseInfo userStatusResponseValue = + new CommandResponseInfo("userStatus", "Integer"); + responseValues.put(userStatusResponseValue, userStatus); + CommandResponseInfo userTypeResponseValue = new CommandResponseInfo("userType", "Integer"); + responseValues.put(userTypeResponseValue, userType); + CommandResponseInfo credentialRuleResponseValue = + new CommandResponseInfo("credentialRule", "Integer"); + responseValues.put(credentialRuleResponseValue, credentialRule); + // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + CommandResponseInfo creatorFabricIndexResponseValue = + new CommandResponseInfo("creatorFabricIndex", "Integer"); + responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); + CommandResponseInfo lastModifiedFabricIndexResponseValue = + new CommandResponseInfo("lastModifiedFabricIndex", "Integer"); + responseValues.put(lastModifiedFabricIndexResponseValue, lastModifiedFabricIndex); + CommandResponseInfo nextUserIndexResponseValue = + new CommandResponseInfo("nextUserIndex", "Integer"); + responseValues.put(nextUserIndexResponseValue, nextUserIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetWeekDayScheduleResponseCallback + implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer weekDayIndex, + Integer userIndex, + Integer status, + Optional daysMask, + Optional startHour, + Optional startMinute, + Optional endHour, + Optional endMinute) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo weekDayIndexResponseValue = + new CommandResponseInfo("weekDayIndex", "Integer"); + responseValues.put(weekDayIndexResponseValue, weekDayIndex); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo daysMaskResponseValue = + new CommandResponseInfo("daysMask", "Optional"); + responseValues.put(daysMaskResponseValue, daysMask); + CommandResponseInfo startHourResponseValue = + new CommandResponseInfo("startHour", "Optional"); + responseValues.put(startHourResponseValue, startHour); + CommandResponseInfo startMinuteResponseValue = + new CommandResponseInfo("startMinute", "Optional"); + responseValues.put(startMinuteResponseValue, startMinute); + CommandResponseInfo endHourResponseValue = + new CommandResponseInfo("endHour", "Optional"); + responseValues.put(endHourResponseValue, endHour); + CommandResponseInfo endMinuteResponseValue = + new CommandResponseInfo("endMinute", "Optional"); + responseValues.put(endMinuteResponseValue, endMinute); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetYearDayScheduleResponseCallback + implements ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer yearDayIndex, + Integer userIndex, + Integer status, + Optional localStartTime, + Optional localEndTime) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo yearDayIndexResponseValue = + new CommandResponseInfo("yearDayIndex", "Integer"); + responseValues.put(yearDayIndexResponseValue, yearDayIndex); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo localStartTimeResponseValue = + new CommandResponseInfo("localStartTime", "Optional"); + responseValues.put(localStartTimeResponseValue, localStartTime); + CommandResponseInfo localEndTimeResponseValue = + new CommandResponseInfo("localEndTime", "Optional"); + responseValues.put(localEndTimeResponseValue, localEndTime); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSetCredentialResponseCallback + implements ChipClusters.DoorLockCluster.SetCredentialResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo nextCredentialIndexResponseValue = + new CommandResponseInfo("nextCredentialIndex", "Integer"); + responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedDoorLockClusterAttributeListAttributeCallback + implements ChipClusters.DoorLockCluster.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 DelegatedElectricalMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.ElectricalMeasurementCluster.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 DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.EthernetNetworkDiagnosticsCluster.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 DelegatedFixedLabelClusterLabelListAttributeCallback + implements ChipClusters.FixedLabelCluster.LabelListAttributeCallback, + 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 DelegatedFixedLabelClusterAttributeListAttributeCallback + implements ChipClusters.FixedLabelCluster.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 DelegatedFlowMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.FlowMeasurementCluster.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 DelegatedArmFailSafeResponseCallback + implements ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedCommissioningCompleteResponseCallback + implements ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSetRegulatoryConfigResponseCallback + implements ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static + class DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback + implements ChipClusters.GeneralCommissioningCluster + .BasicCommissioningInfoListAttributeCallback, + 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 DelegatedGeneralCommissioningClusterAttributeListAttributeCallback + implements ChipClusters.GeneralCommissioningCluster.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 DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.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 DelegatedKeySetReadAllIndicesResponseCallback + implements ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ArrayList groupKeySetIDs) { + Map responseValues = new LinkedHashMap<>(); + // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedKeySetReadResponseCallback + implements ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { + Map responseValues = new LinkedHashMap<>(); + // groupKeySet: Struct GroupKeySet + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback + implements ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback, + 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 DelegatedGroupKeyManagementClusterGroupTableAttributeCallback + implements ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback, + 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 DelegatedGroupKeyManagementClusterAttributeListAttributeCallback + implements ChipClusters.GroupKeyManagementCluster.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 DelegatedAddGroupResponseCallback + implements ChipClusters.GroupsCluster.AddGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetGroupMembershipResponseCallback + implements ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer capacity, ArrayList groupList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); + responseValues.put(capacityResponseValue, capacity); + // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveGroupResponseCallback + implements ChipClusters.GroupsCluster.RemoveGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedViewGroupResponseCallback + implements ChipClusters.GroupsCluster.ViewGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, String groupName) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo groupNameResponseValue = new CommandResponseInfo("groupName", "String"); + responseValues.put(groupNameResponseValue, groupName); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGroupsClusterAttributeListAttributeCallback + implements ChipClusters.GroupsCluster.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 DelegatedIdentifyQueryResponseCallback + implements ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer timeout) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo timeoutResponseValue = new CommandResponseInfo("timeout", "Integer"); + responseValues.put(timeoutResponseValue, timeout); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedIdentifyClusterAttributeListAttributeCallback + implements ChipClusters.IdentifyCluster.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 DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.IlluminanceMeasurementCluster.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 DelegatedSendKeyResponseCallback + implements ChipClusters.KeypadInputCluster.SendKeyResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedKeypadInputClusterAttributeListAttributeCallback + implements ChipClusters.KeypadInputCluster.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 DelegatedLevelControlClusterAttributeListAttributeCallback + implements ChipClusters.LevelControlCluster.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 DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback + implements ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback, + 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 DelegatedLowPowerClusterAttributeListAttributeCallback + implements ChipClusters.LowPowerCluster.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 DelegatedMediaInputClusterMediaInputListAttributeCallback + implements ChipClusters.MediaInputCluster.MediaInputListAttributeCallback, + 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 DelegatedMediaInputClusterAttributeListAttributeCallback + implements ChipClusters.MediaInputCluster.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 DelegatedPlaybackResponseCallback + implements ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedMediaPlaybackClusterAttributeListAttributeCallback + implements ChipClusters.MediaPlaybackCluster.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 DelegatedModeSelectClusterSupportedModesAttributeCallback + implements ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback, + 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 DelegatedModeSelectClusterAttributeListAttributeCallback + implements ChipClusters.ModeSelectCluster.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 DelegatedConnectNetworkResponseCallback + implements ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText, Long ErrorValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = + new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + CommandResponseInfo ErrorValueResponseValue = new CommandResponseInfo("ErrorValue", "Long"); + responseValues.put(ErrorValueResponseValue, ErrorValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNetworkConfigResponseCallback + implements ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = + new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedScanNetworksResponseCallback + implements ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer NetworkingStatus, + String DebugText, + Optional> + WiFiScanResults, + Optional> + ThreadScanResults) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = + new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + // WiFiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + // ThreadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNetworkCommissioningClusterNetworksAttributeCallback + implements ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback, + 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 DelegatedApplyUpdateResponseCallback + implements ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer action, Long delayedActionTime) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo actionResponseValue = new CommandResponseInfo("action", "Integer"); + responseValues.put(actionResponseValue, action); + CommandResponseInfo delayedActionTimeResponseValue = + new CommandResponseInfo("delayedActionTime", "Long"); + responseValues.put(delayedActionTimeResponseValue, delayedActionTime); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedQueryImageResponseCallback + implements ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, + Optional delayedActionTime, + Optional imageURI, + Optional softwareVersion, + Optional softwareVersionString, + Optional updateToken, + Optional userConsentNeeded, + Optional metadataForRequestor) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo delayedActionTimeResponseValue = + new CommandResponseInfo("delayedActionTime", "Optional"); + responseValues.put(delayedActionTimeResponseValue, delayedActionTime); + CommandResponseInfo imageURIResponseValue = + new CommandResponseInfo("imageURI", "Optional"); + responseValues.put(imageURIResponseValue, imageURI); + CommandResponseInfo softwareVersionResponseValue = + new CommandResponseInfo("softwareVersion", "Optional"); + responseValues.put(softwareVersionResponseValue, softwareVersion); + CommandResponseInfo softwareVersionStringResponseValue = + new CommandResponseInfo("softwareVersionString", "Optional"); + responseValues.put(softwareVersionStringResponseValue, softwareVersionString); + CommandResponseInfo updateTokenResponseValue = + new CommandResponseInfo("updateToken", "Optional"); + responseValues.put(updateTokenResponseValue, updateToken); + CommandResponseInfo userConsentNeededResponseValue = + new CommandResponseInfo("userConsentNeeded", "Optional"); + responseValues.put(userConsentNeededResponseValue, userConsentNeeded); + CommandResponseInfo metadataForRequestorResponseValue = + new CommandResponseInfo("metadataForRequestor", "Optional"); + responseValues.put(metadataForRequestorResponseValue, metadataForRequestor); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback + implements ChipClusters.OtaSoftwareUpdateProviderCluster.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 DelegatedOtaSoftwareUpdateRequestorClusterDefaultOtaProvidersAttributeCallback + implements ChipClusters.OtaSoftwareUpdateRequestorCluster + .DefaultOtaProvidersAttributeCallback, + 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 DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback + implements ChipClusters.OtaSoftwareUpdateRequestorCluster.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 DelegatedOccupancySensingClusterAttributeListAttributeCallback + implements ChipClusters.OccupancySensingCluster.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 DelegatedOnOffClusterAttributeListAttributeCallback + implements ChipClusters.OnOffCluster.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 DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback + implements ChipClusters.OnOffSwitchConfigurationCluster.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 DelegatedAttestationResponseCallback + implements ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] AttestationElements, byte[] Signature) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo AttestationElementsResponseValue = + new CommandResponseInfo("AttestationElements", "byte[]"); + responseValues.put(AttestationElementsResponseValue, AttestationElements); + CommandResponseInfo SignatureResponseValue = new CommandResponseInfo("Signature", "byte[]"); + responseValues.put(SignatureResponseValue, Signature); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedCertificateChainResponseCallback + implements ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] Certificate) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo CertificateResponseValue = + new CommandResponseInfo("Certificate", "byte[]"); + responseValues.put(CertificateResponseValue, Certificate); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNOCResponseCallback + implements ChipClusters.OperationalCredentialsCluster.NOCResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer StatusCode, Integer FabricIndex, String DebugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo StatusCodeResponseValue = + new CommandResponseInfo("StatusCode", "Integer"); + responseValues.put(StatusCodeResponseValue, StatusCode); + CommandResponseInfo FabricIndexResponseValue = + new CommandResponseInfo("FabricIndex", "Integer"); + responseValues.put(FabricIndexResponseValue, FabricIndex); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedOpCSRResponseCallback + implements ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] NOCSRElements, byte[] AttestationSignature) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NOCSRElementsResponseValue = + new CommandResponseInfo("NOCSRElements", "byte[]"); + responseValues.put(NOCSRElementsResponseValue, NOCSRElements); + CommandResponseInfo AttestationSignatureResponseValue = + new CommandResponseInfo("AttestationSignature", "byte[]"); + responseValues.put(AttestationSignatureResponseValue, AttestationSignature); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedOperationalCredentialsClusterNOCsAttributeCallback + implements ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback, + 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 DelegatedOperationalCredentialsClusterFabricsListAttributeCallback + implements ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback, + 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 DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback + implements ChipClusters.OperationalCredentialsCluster + .TrustedRootCertificatesAttributeCallback, + 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 DelegatedOperationalCredentialsClusterAttributeListAttributeCallback + implements ChipClusters.OperationalCredentialsCluster.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 DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback + implements ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback, + 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 DelegatedPowerSourceClusterAttributeListAttributeCallback + implements ChipClusters.PowerSourceCluster.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 DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback + implements ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback, + 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 DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback + implements ChipClusters.PowerSourceConfigurationCluster.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 DelegatedPressureMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.PressureMeasurementCluster.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 DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback + implements ChipClusters.PumpConfigurationAndControlCluster.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 DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.RelativeHumidityMeasurementCluster.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 DelegatedAddSceneResponseCallback + implements ChipClusters.ScenesCluster.AddSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetSceneMembershipResponseCallback + implements ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, + Integer capacity, + Integer groupId, + Integer sceneCount, + ArrayList sceneList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); + responseValues.put(capacityResponseValue, capacity); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneCountResponseValue = + new CommandResponseInfo("sceneCount", "Integer"); + responseValues.put(sceneCountResponseValue, sceneCount); + // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveAllScenesResponseCallback + implements ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveSceneResponseCallback + implements ChipClusters.ScenesCluster.RemoveSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedStoreSceneResponseCallback + implements ChipClusters.ScenesCluster.StoreSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedViewSceneResponseCallback + implements ChipClusters.ScenesCluster.ViewSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + CommandResponseInfo transitionTimeResponseValue = + new CommandResponseInfo("transitionTime", "Integer"); + responseValues.put(transitionTimeResponseValue, transitionTime); + CommandResponseInfo sceneNameResponseValue = new CommandResponseInfo("sceneName", "String"); + responseValues.put(sceneNameResponseValue, sceneName); + // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedScenesClusterAttributeListAttributeCallback + implements ChipClusters.ScenesCluster.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 DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback + implements ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback, + 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 DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.SoftwareDiagnosticsCluster.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 DelegatedSwitchClusterAttributeListAttributeCallback + implements ChipClusters.SwitchCluster.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 DelegatedNavigateTargetResponseCallback + implements ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback + implements ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback, + 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 DelegatedTargetNavigatorClusterAttributeListAttributeCallback + implements ChipClusters.TargetNavigatorCluster.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 DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.TemperatureMeasurementCluster.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 DelegatedBooleanResponseCallback + implements ChipClusters.TestClusterCluster.BooleanResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Boolean value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Boolean"); + responseValues.put(valueResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSimpleStructResponseCallback + implements ChipClusters.TestClusterCluster.SimpleStructResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1) { + Map responseValues = new LinkedHashMap<>(); + // arg1: Struct SimpleStruct + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestAddArgumentsResponseCallback + implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer returnValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo returnValueResponseValue = + new CommandResponseInfo("returnValue", "Integer"); + responseValues.put(returnValueResponseValue, returnValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestEmitTestEventResponseCallback + implements ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Long value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Long"); + responseValues.put(valueResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestEnumsResponseCallback + implements ChipClusters.TestClusterCluster.TestEnumsResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer arg1, Integer arg2) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo arg1ResponseValue = new CommandResponseInfo("arg1", "Integer"); + responseValues.put(arg1ResponseValue, arg1); + CommandResponseInfo arg2ResponseValue = new CommandResponseInfo("arg2", "Integer"); + responseValues.put(arg2ResponseValue, arg2); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestListInt8UReverseResponseCallback + implements ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ArrayList arg1) { + Map responseValues = new LinkedHashMap<>(); + // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestNullableOptionalResponseCallback + implements ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Boolean wasPresent, + Optional wasNull, + Optional value, + @Nullable Optional originalValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo wasPresentResponseValue = + new CommandResponseInfo("wasPresent", "Boolean"); + responseValues.put(wasPresentResponseValue, wasPresent); + CommandResponseInfo wasNullResponseValue = + new CommandResponseInfo("wasNull", "Optional"); + responseValues.put(wasNullResponseValue, wasNull); + CommandResponseInfo valueResponseValue = + new CommandResponseInfo("value", "Optional"); + responseValues.put(valueResponseValue, value); + CommandResponseInfo originalValueResponseValue = + new CommandResponseInfo("originalValue", "Optional"); + responseValues.put(originalValueResponseValue, originalValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestSpecificResponseCallback + implements ChipClusters.TestClusterCluster.TestSpecificResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer returnValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo returnValueResponseValue = + new CommandResponseInfo("returnValue", "Integer"); + responseValues.put(returnValueResponseValue, returnValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestClusterClusterListInt8uAttributeCallback + implements ChipClusters.TestClusterCluster.ListInt8uAttributeCallback, + 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 DelegatedTestClusterClusterListOctetStringAttributeCallback + implements ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback, + 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 DelegatedTestClusterClusterListStructOctetStringAttributeCallback + implements ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback, + 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 DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback + implements ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback, + 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 DelegatedTestClusterClusterListLongOctetStringAttributeCallback + implements ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback, + 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 DelegatedTestClusterClusterAttributeListAttributeCallback + implements ChipClusters.TestClusterCluster.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 DelegatedGetRelayStatusLogResponseCallback + implements ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer timeOfDay, + Integer relayStatus, + Integer localTemperature, + Integer humidityInPercentage, + Integer setpoint, + Integer unreadEntries) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo timeOfDayResponseValue = new CommandResponseInfo("timeOfDay", "Integer"); + responseValues.put(timeOfDayResponseValue, timeOfDay); + CommandResponseInfo relayStatusResponseValue = + new CommandResponseInfo("relayStatus", "Integer"); + responseValues.put(relayStatusResponseValue, relayStatus); + CommandResponseInfo localTemperatureResponseValue = + new CommandResponseInfo("localTemperature", "Integer"); + responseValues.put(localTemperatureResponseValue, localTemperature); + CommandResponseInfo humidityInPercentageResponseValue = + new CommandResponseInfo("humidityInPercentage", "Integer"); + responseValues.put(humidityInPercentageResponseValue, humidityInPercentage); + CommandResponseInfo setpointResponseValue = new CommandResponseInfo("setpoint", "Integer"); + responseValues.put(setpointResponseValue, setpoint); + CommandResponseInfo unreadEntriesResponseValue = + new CommandResponseInfo("unreadEntries", "Integer"); + responseValues.put(unreadEntriesResponseValue, unreadEntries); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetWeeklyScheduleResponseCallback + implements ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo numberOfTransitionsForSequenceResponseValue = + new CommandResponseInfo("numberOfTransitionsForSequence", "Integer"); + responseValues.put( + numberOfTransitionsForSequenceResponseValue, numberOfTransitionsForSequence); + CommandResponseInfo dayOfWeekForSequenceResponseValue = + new CommandResponseInfo("dayOfWeekForSequence", "Integer"); + responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); + CommandResponseInfo modeForSequenceResponseValue = + new CommandResponseInfo("modeForSequence", "Integer"); + responseValues.put(modeForSequenceResponseValue, modeForSequence); + // payload: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedThermostatClusterAttributeListAttributeCallback + implements ChipClusters.ThermostatCluster.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 DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback + implements ChipClusters.ThermostatUserInterfaceConfigurationCluster + .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 DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster + .OperationalDatasetComponentsAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster + .ActiveNetworkFaultsListAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.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 DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback + implements ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback, + 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 DelegatedUserLabelClusterLabelListAttributeCallback + implements ChipClusters.UserLabelCluster.LabelListAttributeCallback, + 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 DelegatedWakeOnLanClusterAttributeListAttributeCallback + implements ChipClusters.WakeOnLanCluster.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 DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.WiFiNetworkDiagnosticsCluster.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 DelegatedWindowCoveringClusterAttributeListAttributeCallback + implements ChipClusters.WindowCoveringCluster.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 Map getClusterMap() { + Map clusterMap = initializeClusterMap(); + Map> commandMap = getCommandMap(); + combineCommand(clusterMap, commandMap); + Map> readAttributeMap = + new ClusterReadMapping().getReadAttributeMap(); + combineCommand(clusterMap, readAttributeMap); + Map> writeAttributeMap = + new ClusterWriteMapping().getWriteAttributeMap(); + combineCommand(clusterMap, writeAttributeMap); + return clusterMap; + } + + public Map initializeClusterMap() { + Map clusterMap = new HashMap<>(); + ClusterInfo accessControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AccessControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("accessControl", accessControlClusterInfo); + ClusterInfo accountLoginClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("accountLogin", accountLoginClusterInfo); + ClusterInfo administratorCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); + ClusterInfo applicationBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("applicationBasic", applicationBasicClusterInfo); + ClusterInfo applicationLauncherClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); + ClusterInfo audioOutputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("audioOutput", audioOutputClusterInfo); + ClusterInfo barrierControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("barrierControl", barrierControlClusterInfo); + ClusterInfo basicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("basic", basicClusterInfo); + ClusterInfo binaryInputBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); + ClusterInfo bindingClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("binding", bindingClusterInfo); + ClusterInfo booleanStateClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("booleanState", booleanStateClusterInfo); + ClusterInfo bridgedActionsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("bridgedActions", bridgedActionsClusterInfo); + ClusterInfo bridgedDeviceBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); + ClusterInfo channelClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ChannelCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("channel", channelClusterInfo); + ClusterInfo colorControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("colorControl", colorControlClusterInfo); + ClusterInfo contentLauncherClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("contentLauncher", contentLauncherClusterInfo); + ClusterInfo descriptorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("descriptor", descriptorClusterInfo); + ClusterInfo diagnosticLogsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); + ClusterInfo doorLockClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("doorLock", doorLockClusterInfo); + ClusterInfo electricalMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); + ClusterInfo ethernetNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); + ClusterInfo fixedLabelClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("fixedLabel", fixedLabelClusterInfo); + ClusterInfo flowMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); + ClusterInfo generalCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); + ClusterInfo generalDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); + ClusterInfo groupKeyManagementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); + ClusterInfo groupsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("groups", groupsClusterInfo); + ClusterInfo identifyClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("identify", identifyClusterInfo); + ClusterInfo illuminanceMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); + ClusterInfo keypadInputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("keypadInput", keypadInputClusterInfo); + ClusterInfo levelControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("levelControl", levelControlClusterInfo); + ClusterInfo localizationConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LocalizationConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("localizationConfiguration", localizationConfigurationClusterInfo); + ClusterInfo lowPowerClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("lowPower", lowPowerClusterInfo); + ClusterInfo mediaInputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("mediaInput", mediaInputClusterInfo); + ClusterInfo mediaPlaybackClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); + ClusterInfo modeSelectClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("modeSelect", modeSelectClusterInfo); + ClusterInfo networkCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); + ClusterInfo otaSoftwareUpdateProviderClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); + ClusterInfo otaSoftwareUpdateRequestorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); + ClusterInfo occupancySensingClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("occupancySensing", occupancySensingClusterInfo); + ClusterInfo onOffClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("onOff", onOffClusterInfo); + ClusterInfo onOffSwitchConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); + ClusterInfo operationalCredentialsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); + ClusterInfo powerSourceClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("powerSource", powerSourceClusterInfo); + ClusterInfo powerSourceConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PowerSourceConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInfo); + ClusterInfo pressureMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); + ClusterInfo pumpConfigurationAndControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); + ClusterInfo relativeHumidityMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); + ClusterInfo scenesClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("scenes", scenesClusterInfo); + ClusterInfo softwareDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); + ClusterInfo switchClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("switch", switchClusterInfo); + ClusterInfo targetNavigatorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("targetNavigator", targetNavigatorClusterInfo); + ClusterInfo temperatureMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); + ClusterInfo testClusterClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("testCluster", testClusterClusterInfo); + ClusterInfo thermostatClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("thermostat", thermostatClusterInfo); + ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put( + "thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); + ClusterInfo threadNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); + ClusterInfo timeFormatLocalizationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TimeFormatLocalizationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("timeFormatLocalization", timeFormatLocalizationClusterInfo); + ClusterInfo unitLocalizationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.UnitLocalizationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("unitLocalization", unitLocalizationClusterInfo); + ClusterInfo userLabelClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.UserLabelCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("userLabel", userLabelClusterInfo); + ClusterInfo wakeOnLanClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); + ClusterInfo wiFiNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); + ClusterInfo windowCoveringClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("windowCovering", windowCoveringClusterInfo); + return clusterMap; + } + + public void combineCommand( + Map destination, Map> source) { + destination.get("accessControl").combineCommands(source.get("accessControl")); + destination.get("accountLogin").combineCommands(source.get("accountLogin")); + destination + .get("administratorCommissioning") + .combineCommands(source.get("administratorCommissioning")); + destination.get("applicationBasic").combineCommands(source.get("applicationBasic")); + destination.get("applicationLauncher").combineCommands(source.get("applicationLauncher")); + destination.get("audioOutput").combineCommands(source.get("audioOutput")); + destination.get("barrierControl").combineCommands(source.get("barrierControl")); + destination.get("basic").combineCommands(source.get("basic")); + destination.get("binaryInputBasic").combineCommands(source.get("binaryInputBasic")); + destination.get("binding").combineCommands(source.get("binding")); + destination.get("booleanState").combineCommands(source.get("booleanState")); + destination.get("bridgedActions").combineCommands(source.get("bridgedActions")); + destination.get("bridgedDeviceBasic").combineCommands(source.get("bridgedDeviceBasic")); + destination.get("channel").combineCommands(source.get("channel")); + destination.get("colorControl").combineCommands(source.get("colorControl")); + destination.get("contentLauncher").combineCommands(source.get("contentLauncher")); + destination.get("descriptor").combineCommands(source.get("descriptor")); + destination.get("diagnosticLogs").combineCommands(source.get("diagnosticLogs")); + destination.get("doorLock").combineCommands(source.get("doorLock")); + destination.get("electricalMeasurement").combineCommands(source.get("electricalMeasurement")); + destination + .get("ethernetNetworkDiagnostics") + .combineCommands(source.get("ethernetNetworkDiagnostics")); + destination.get("fixedLabel").combineCommands(source.get("fixedLabel")); + destination.get("flowMeasurement").combineCommands(source.get("flowMeasurement")); + destination.get("generalCommissioning").combineCommands(source.get("generalCommissioning")); + destination.get("generalDiagnostics").combineCommands(source.get("generalDiagnostics")); + destination.get("groupKeyManagement").combineCommands(source.get("groupKeyManagement")); + destination.get("groups").combineCommands(source.get("groups")); + destination.get("identify").combineCommands(source.get("identify")); + destination.get("illuminanceMeasurement").combineCommands(source.get("illuminanceMeasurement")); + destination.get("keypadInput").combineCommands(source.get("keypadInput")); + destination.get("levelControl").combineCommands(source.get("levelControl")); + destination + .get("localizationConfiguration") + .combineCommands(source.get("localizationConfiguration")); + destination.get("lowPower").combineCommands(source.get("lowPower")); + destination.get("mediaInput").combineCommands(source.get("mediaInput")); + destination.get("mediaPlayback").combineCommands(source.get("mediaPlayback")); + destination.get("modeSelect").combineCommands(source.get("modeSelect")); + destination.get("networkCommissioning").combineCommands(source.get("networkCommissioning")); + destination + .get("otaSoftwareUpdateProvider") + .combineCommands(source.get("otaSoftwareUpdateProvider")); + destination + .get("otaSoftwareUpdateRequestor") + .combineCommands(source.get("otaSoftwareUpdateRequestor")); + destination.get("occupancySensing").combineCommands(source.get("occupancySensing")); + destination.get("onOff").combineCommands(source.get("onOff")); + destination + .get("onOffSwitchConfiguration") + .combineCommands(source.get("onOffSwitchConfiguration")); + destination.get("operationalCredentials").combineCommands(source.get("operationalCredentials")); + destination.get("powerSource").combineCommands(source.get("powerSource")); + destination + .get("powerSourceConfiguration") + .combineCommands(source.get("powerSourceConfiguration")); + destination.get("pressureMeasurement").combineCommands(source.get("pressureMeasurement")); + destination + .get("pumpConfigurationAndControl") + .combineCommands(source.get("pumpConfigurationAndControl")); + destination + .get("relativeHumidityMeasurement") + .combineCommands(source.get("relativeHumidityMeasurement")); + destination.get("scenes").combineCommands(source.get("scenes")); + destination.get("softwareDiagnostics").combineCommands(source.get("softwareDiagnostics")); + destination.get("switch").combineCommands(source.get("switch")); + destination.get("targetNavigator").combineCommands(source.get("targetNavigator")); + destination.get("temperatureMeasurement").combineCommands(source.get("temperatureMeasurement")); + destination.get("testCluster").combineCommands(source.get("testCluster")); + destination.get("thermostat").combineCommands(source.get("thermostat")); + destination + .get("thermostatUserInterfaceConfiguration") + .combineCommands(source.get("thermostatUserInterfaceConfiguration")); + destination + .get("threadNetworkDiagnostics") + .combineCommands(source.get("threadNetworkDiagnostics")); + destination.get("timeFormatLocalization").combineCommands(source.get("timeFormatLocalization")); + destination.get("unitLocalization").combineCommands(source.get("unitLocalization")); + destination.get("userLabel").combineCommands(source.get("userLabel")); + destination.get("wakeOnLan").combineCommands(source.get("wakeOnLan")); + destination.get("wiFiNetworkDiagnostics").combineCommands(source.get("wiFiNetworkDiagnostics")); + destination.get("windowCovering").combineCommands(source.get("windowCovering")); + } + + @SuppressWarnings("unchecked") + public Map> getCommandMap() { + Map> commandMap = new HashMap<>(); + Map accessControlClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("accessControl", accessControlClusterInteractionInfoMap); + Map accountLoginClusterInteractionInfoMap = new LinkedHashMap<>(); + Map accountLogingetSetupPINRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = + new CommandParameterInfo("tempAccountIdentifier", String.class); + accountLogingetSetupPINRequestCommandParams.put( + "tempAccountIdentifier", + accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); + + InteractionInfo accountLogingetSetupPINRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .getSetupPINRequest( + (ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback) callback, + (String) commandArguments.get("tempAccountIdentifier"), + 10000); + }, + () -> new DelegatedGetSetupPINResponseCallback(), + accountLogingetSetupPINRequestCommandParams); + accountLoginClusterInteractionInfoMap.put( + "getSetupPINRequest", accountLogingetSetupPINRequestInteractionInfo); + Map accountLoginloginRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = + new CommandParameterInfo("tempAccountIdentifier", String.class); + accountLoginloginRequestCommandParams.put( + "tempAccountIdentifier", accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); + + CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = + new CommandParameterInfo("setupPIN", String.class); + accountLoginloginRequestCommandParams.put( + "setupPIN", accountLoginloginRequestsetupPINCommandParameterInfo); + + InteractionInfo accountLoginloginRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .loginRequest( + (DefaultClusterCallback) callback, + (String) commandArguments.get("tempAccountIdentifier"), + (String) commandArguments.get("setupPIN"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + accountLoginloginRequestCommandParams); + accountLoginClusterInteractionInfoMap.put( + "loginRequest", accountLoginloginRequestInteractionInfo); + Map accountLoginlogoutRequestCommandParams = + new LinkedHashMap(); + InteractionInfo accountLoginlogoutRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .logoutRequest((DefaultClusterCallback) callback, 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + accountLoginlogoutRequestCommandParams); + accountLoginClusterInteractionInfoMap.put( + "logoutRequest", accountLoginlogoutRequestInteractionInfo); + commandMap.put("accountLogin", accountLoginClusterInteractionInfoMap); + Map administratorCommissioningClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map + administratorCommissioningopenBasicCommissioningWindowCommandParams = + new LinkedHashMap(); + CommandParameterInfo + administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = + new CommandParameterInfo("commissioningTimeout", Integer.class); + administratorCommissioningopenBasicCommissioningWindowCommandParams.put( + "commissioningTimeout", + administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); + + InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .openBasicCommissioningWindow( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("commissioningTimeout"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningopenBasicCommissioningWindowCommandParams); + administratorCommissioningClusterInteractionInfoMap.put( + "openBasicCommissioningWindow", + administratorCommissioningopenBasicCommissioningWindowInteractionInfo); + Map + administratorCommissioningopenCommissioningWindowCommandParams = + new LinkedHashMap(); + CommandParameterInfo + administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = + new CommandParameterInfo("commissioningTimeout", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "commissioningTimeout", + administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = + new CommandParameterInfo("PAKEVerifier", byte[].class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "PAKEVerifier", + administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = + new CommandParameterInfo("discriminator", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "discriminator", + administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = + new CommandParameterInfo("iterations", Long.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "iterations", + administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = + new CommandParameterInfo("salt", byte[].class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "salt", administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = + new CommandParameterInfo("passcodeID", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "passcodeID", + administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); + + InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .openCommissioningWindow( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("commissioningTimeout"), + (byte[]) commandArguments.get("PAKEVerifier"), + (Integer) commandArguments.get("discriminator"), + (Long) commandArguments.get("iterations"), + (byte[]) commandArguments.get("salt"), + (Integer) commandArguments.get("passcodeID"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningopenCommissioningWindowCommandParams); + administratorCommissioningClusterInteractionInfoMap.put( + "openCommissioningWindow", + administratorCommissioningopenCommissioningWindowInteractionInfo); + Map administratorCommissioningrevokeCommissioningCommandParams = + new LinkedHashMap(); + InteractionInfo administratorCommissioningrevokeCommissioningInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .revokeCommissioning((DefaultClusterCallback) callback, 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningrevokeCommissioningCommandParams); + administratorCommissioningClusterInteractionInfoMap.put( + "revokeCommissioning", administratorCommissioningrevokeCommissioningInteractionInfo); + commandMap.put( + "administratorCommissioning", administratorCommissioningClusterInteractionInfoMap); + Map applicationBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("applicationBasic", applicationBasicClusterInteractionInfoMap); + Map applicationLauncherClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map applicationLauncherhideAppRequestCommandParams = + new LinkedHashMap(); + InteractionInfo applicationLauncherhideAppRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .hideAppRequest( + (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, + (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application")); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherhideAppRequestCommandParams); + applicationLauncherClusterInteractionInfoMap.put( + "hideAppRequest", applicationLauncherhideAppRequestInteractionInfo); + Map applicationLauncherlaunchAppRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = + new CommandParameterInfo("data", String.class); + applicationLauncherlaunchAppRequestCommandParams.put( + "data", applicationLauncherlaunchAppRequestdataCommandParameterInfo); + + InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .launchAppRequest( + (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, + (String) commandArguments.get("data"), + (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application")); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherlaunchAppRequestCommandParams); + applicationLauncherClusterInteractionInfoMap.put( + "launchAppRequest", applicationLauncherlaunchAppRequestInteractionInfo); + Map applicationLauncherstopAppRequestCommandParams = + new LinkedHashMap(); + InteractionInfo applicationLauncherstopAppRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .stopAppRequest( + (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, + (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application")); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherstopAppRequestCommandParams); + applicationLauncherClusterInteractionInfoMap.put( + "stopAppRequest", applicationLauncherstopAppRequestInteractionInfo); + commandMap.put("applicationLauncher", applicationLauncherClusterInteractionInfoMap); + Map audioOutputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map audioOutputrenameOutputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + audioOutputrenameOutputRequestCommandParams.put( + "index", audioOutputrenameOutputRequestindexCommandParameterInfo); + + CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = + new CommandParameterInfo("name", String.class); + audioOutputrenameOutputRequestCommandParams.put( + "name", audioOutputrenameOutputRequestnameCommandParameterInfo); + + InteractionInfo audioOutputrenameOutputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .renameOutputRequest( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("index"), + (String) commandArguments.get("name")); + }, + () -> new DelegatedDefaultClusterCallback(), + audioOutputrenameOutputRequestCommandParams); + audioOutputClusterInteractionInfoMap.put( + "renameOutputRequest", audioOutputrenameOutputRequestInteractionInfo); + Map audioOutputselectOutputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + audioOutputselectOutputRequestCommandParams.put( + "index", audioOutputselectOutputRequestindexCommandParameterInfo); + + InteractionInfo audioOutputselectOutputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .selectOutputRequest( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("index")); + }, + () -> new DelegatedDefaultClusterCallback(), + audioOutputselectOutputRequestCommandParams); + audioOutputClusterInteractionInfoMap.put( + "selectOutputRequest", audioOutputselectOutputRequestInteractionInfo); + commandMap.put("audioOutput", audioOutputClusterInteractionInfoMap); + Map barrierControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map barrierControlbarrierControlGoToPercentCommandParams = + new LinkedHashMap(); + CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = + new CommandParameterInfo("percentOpen", Integer.class); + barrierControlbarrierControlGoToPercentCommandParams.put( + "percentOpen", barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); + + InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .barrierControlGoToPercent( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("percentOpen")); + }, + () -> new DelegatedDefaultClusterCallback(), + barrierControlbarrierControlGoToPercentCommandParams); + barrierControlClusterInteractionInfoMap.put( + "barrierControlGoToPercent", barrierControlbarrierControlGoToPercentInteractionInfo); + Map barrierControlbarrierControlStopCommandParams = + new LinkedHashMap(); + InteractionInfo barrierControlbarrierControlStopInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .barrierControlStop((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + barrierControlbarrierControlStopCommandParams); + barrierControlClusterInteractionInfoMap.put( + "barrierControlStop", barrierControlbarrierControlStopInteractionInfo); + commandMap.put("barrierControl", barrierControlClusterInteractionInfoMap); + Map basicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("basic", basicClusterInteractionInfoMap); + Map binaryInputBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("binaryInputBasic", binaryInputBasicClusterInteractionInfoMap); + Map bindingClusterInteractionInfoMap = new LinkedHashMap<>(); + Map bindingbindCommandParams = + new LinkedHashMap(); + CommandParameterInfo bindingbindnodeIdCommandParameterInfo = + new CommandParameterInfo("nodeId", Long.class); + bindingbindCommandParams.put("nodeId", bindingbindnodeIdCommandParameterInfo); + + CommandParameterInfo bindingbindgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + bindingbindCommandParams.put("groupId", bindingbindgroupIdCommandParameterInfo); + + CommandParameterInfo bindingbindendpointIdCommandParameterInfo = + new CommandParameterInfo("endpointId", Integer.class); + bindingbindCommandParams.put("endpointId", bindingbindendpointIdCommandParameterInfo); + + CommandParameterInfo bindingbindclusterIdCommandParameterInfo = + new CommandParameterInfo("clusterId", Long.class); + bindingbindCommandParams.put("clusterId", bindingbindclusterIdCommandParameterInfo); + + InteractionInfo bindingbindInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .bind( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("nodeId"), + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("endpointId"), + (Long) commandArguments.get("clusterId")); + }, + () -> new DelegatedDefaultClusterCallback(), + bindingbindCommandParams); + bindingClusterInteractionInfoMap.put("bind", bindingbindInteractionInfo); + Map bindingunbindCommandParams = + new LinkedHashMap(); + CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = + new CommandParameterInfo("nodeId", Long.class); + bindingunbindCommandParams.put("nodeId", bindingunbindnodeIdCommandParameterInfo); + + CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + bindingunbindCommandParams.put("groupId", bindingunbindgroupIdCommandParameterInfo); + + CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = + new CommandParameterInfo("endpointId", Integer.class); + bindingunbindCommandParams.put("endpointId", bindingunbindendpointIdCommandParameterInfo); + + CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = + new CommandParameterInfo("clusterId", Long.class); + bindingunbindCommandParams.put("clusterId", bindingunbindclusterIdCommandParameterInfo); + + InteractionInfo bindingunbindInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .unbind( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("nodeId"), + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("endpointId"), + (Long) commandArguments.get("clusterId")); + }, + () -> new DelegatedDefaultClusterCallback(), + bindingunbindCommandParams); + bindingClusterInteractionInfoMap.put("unbind", bindingunbindInteractionInfo); + commandMap.put("binding", bindingClusterInteractionInfoMap); + Map booleanStateClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("booleanState", booleanStateClusterInteractionInfoMap); + Map bridgedActionsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map bridgedActionsdisableActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsdisableActionCommandParams.put( + "actionID", bridgedActionsdisableActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsdisableActionCommandParams.put( + "invokeID", bridgedActionsdisableActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsdisableActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .disableAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsdisableActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "disableAction", bridgedActionsdisableActionInteractionInfo); + Map bridgedActionsdisableActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsdisableActionWithDurationCommandParams.put( + "actionID", bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsdisableActionWithDurationCommandParams.put( + "invokeID", bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionsdisableActionWithDurationCommandParams.put( + "duration", bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .disableActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsdisableActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "disableActionWithDuration", bridgedActionsdisableActionWithDurationInteractionInfo); + Map bridgedActionsenableActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsenableActionCommandParams.put( + "actionID", bridgedActionsenableActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsenableActionCommandParams.put( + "invokeID", bridgedActionsenableActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsenableActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .enableAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsenableActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "enableAction", bridgedActionsenableActionInteractionInfo); + Map bridgedActionsenableActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsenableActionWithDurationCommandParams.put( + "actionID", bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsenableActionWithDurationCommandParams.put( + "invokeID", bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionsenableActionWithDurationCommandParams.put( + "duration", bridgedActionsenableActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .enableActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsenableActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "enableActionWithDuration", bridgedActionsenableActionWithDurationInteractionInfo); + Map bridgedActionsinstantActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsinstantActionCommandParams.put( + "actionID", bridgedActionsinstantActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsinstantActionCommandParams.put( + "invokeID", bridgedActionsinstantActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsinstantActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .instantAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsinstantActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "instantAction", bridgedActionsinstantActionInteractionInfo); + Map bridgedActionsinstantActionWithTransitionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsinstantActionWithTransitionCommandParams.put( + "actionID", bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsinstantActionWithTransitionCommandParams.put( + "invokeID", bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); + + CommandParameterInfo + bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + bridgedActionsinstantActionWithTransitionCommandParams.put( + "transitionTime", + bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); + + InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .instantActionWithTransition( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsinstantActionWithTransitionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "instantActionWithTransition", bridgedActionsinstantActionWithTransitionInteractionInfo); + Map bridgedActionspauseActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionspauseActionCommandParams.put( + "actionID", bridgedActionspauseActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionspauseActionCommandParams.put( + "invokeID", bridgedActionspauseActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionspauseActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .pauseAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionspauseActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "pauseAction", bridgedActionspauseActionInteractionInfo); + Map bridgedActionspauseActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionspauseActionWithDurationCommandParams.put( + "actionID", bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionspauseActionWithDurationCommandParams.put( + "invokeID", bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionspauseActionWithDurationCommandParams.put( + "duration", bridgedActionspauseActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .pauseActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionspauseActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "pauseActionWithDuration", bridgedActionspauseActionWithDurationInteractionInfo); + Map bridgedActionsresumeActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsresumeActionCommandParams.put( + "actionID", bridgedActionsresumeActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsresumeActionCommandParams.put( + "invokeID", bridgedActionsresumeActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsresumeActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .resumeAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsresumeActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "resumeAction", bridgedActionsresumeActionInteractionInfo); + Map bridgedActionsstartActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstartActionCommandParams.put( + "actionID", bridgedActionsstartActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstartActionCommandParams.put( + "invokeID", bridgedActionsstartActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsstartActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .startAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstartActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "startAction", bridgedActionsstartActionInteractionInfo); + Map bridgedActionsstartActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstartActionWithDurationCommandParams.put( + "actionID", bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstartActionWithDurationCommandParams.put( + "invokeID", bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionsstartActionWithDurationCommandParams.put( + "duration", bridgedActionsstartActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .startActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstartActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "startActionWithDuration", bridgedActionsstartActionWithDurationInteractionInfo); + Map bridgedActionsstopActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstopActionCommandParams.put( + "actionID", bridgedActionsstopActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstopActionCommandParams.put( + "invokeID", bridgedActionsstopActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsstopActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .stopAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstopActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "stopAction", bridgedActionsstopActionInteractionInfo); + commandMap.put("bridgedActions", bridgedActionsClusterInteractionInfoMap); + Map bridgedDeviceBasicClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInteractionInfoMap); + Map channelClusterInteractionInfoMap = new LinkedHashMap<>(); + Map channelchangeChannelByNumberRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = + new CommandParameterInfo("majorNumber", Integer.class); + channelchangeChannelByNumberRequestCommandParams.put( + "majorNumber", channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); + + CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = + new CommandParameterInfo("minorNumber", Integer.class); + channelchangeChannelByNumberRequestCommandParams.put( + "minorNumber", channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); + + InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .changeChannelByNumberRequest( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("majorNumber"), + (Integer) commandArguments.get("minorNumber")); + }, + () -> new DelegatedDefaultClusterCallback(), + channelchangeChannelByNumberRequestCommandParams); + channelClusterInteractionInfoMap.put( + "changeChannelByNumberRequest", channelchangeChannelByNumberRequestInteractionInfo); + Map channelchangeChannelRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = + new CommandParameterInfo("match", String.class); + channelchangeChannelRequestCommandParams.put( + "match", channelchangeChannelRequestmatchCommandParameterInfo); + + InteractionInfo channelchangeChannelRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .changeChannelRequest( + (ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback, + (String) commandArguments.get("match")); + }, + () -> new DelegatedChangeChannelResponseCallback(), + channelchangeChannelRequestCommandParams); + channelClusterInteractionInfoMap.put( + "changeChannelRequest", channelchangeChannelRequestInteractionInfo); + Map channelskipChannelRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = + new CommandParameterInfo("count", Integer.class); + channelskipChannelRequestCommandParams.put( + "count", channelskipChannelRequestcountCommandParameterInfo); + + InteractionInfo channelskipChannelRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .skipChannelRequest( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("count")); + }, + () -> new DelegatedDefaultClusterCallback(), + channelskipChannelRequestCommandParams); + channelClusterInteractionInfoMap.put( + "skipChannelRequest", channelskipChannelRequestInteractionInfo); + commandMap.put("channel", channelClusterInteractionInfoMap); + Map colorControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map colorControlcolorLoopSetCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = + new CommandParameterInfo("updateFlags", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "updateFlags", colorControlcolorLoopSetupdateFlagsCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = + new CommandParameterInfo("action", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "action", colorControlcolorLoopSetactionCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = + new CommandParameterInfo("direction", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "direction", colorControlcolorLoopSetdirectionCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = + new CommandParameterInfo("time", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "time", colorControlcolorLoopSettimeCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = + new CommandParameterInfo("startHue", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "startHue", colorControlcolorLoopSetstartHueCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "optionsMask", colorControlcolorLoopSetoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "optionsOverride", colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlcolorLoopSetInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .colorLoopSet( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("updateFlags"), + (Integer) commandArguments.get("action"), + (Integer) commandArguments.get("direction"), + (Integer) commandArguments.get("time"), + (Integer) commandArguments.get("startHue"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlcolorLoopSetCommandParams); + colorControlClusterInteractionInfoMap.put( + "colorLoopSet", colorControlcolorLoopSetInteractionInfo); + Map colorControlenhancedMoveHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "moveMode", colorControlenhancedMoveHuemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "rate", colorControlenhancedMoveHuerateCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "optionsMask", colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "optionsOverride", colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveHueCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveHue", colorControlenhancedMoveHueInteractionInfo); + Map colorControlenhancedMoveToHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = + new CommandParameterInfo("enhancedHue", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "enhancedHue", colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = + new CommandParameterInfo("direction", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "direction", colorControlenhancedMoveToHuedirectionCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "transitionTime", colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "optionsMask", colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "optionsOverride", colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveToHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveToHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("enhancedHue"), + (Integer) commandArguments.get("direction"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveToHueCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveToHue", colorControlenhancedMoveToHueInteractionInfo); + Map colorControlenhancedMoveToHueAndSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = + new CommandParameterInfo("enhancedHue", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "enhancedHue", colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = + new CommandParameterInfo("saturation", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "saturation", colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); + + CommandParameterInfo + colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "transitionTime", + colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "optionsMask", colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo + colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "optionsOverride", + colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveToHueAndSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("enhancedHue"), + (Integer) commandArguments.get("saturation"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveToHueAndSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveToHueAndSaturation", + colorControlenhancedMoveToHueAndSaturationInteractionInfo); + Map colorControlenhancedStepHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "stepMode", colorControlenhancedStepHuestepModeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "stepSize", colorControlenhancedStepHuestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "transitionTime", colorControlenhancedStepHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "optionsMask", colorControlenhancedStepHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "optionsOverride", colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedStepHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedStepHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedStepHueCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedStepHue", colorControlenhancedStepHueInteractionInfo); + Map colorControlmoveColorCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = + new CommandParameterInfo("rateX", Integer.class); + colorControlmoveColorCommandParams.put("rateX", colorControlmoveColorrateXCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = + new CommandParameterInfo("rateY", Integer.class); + colorControlmoveColorCommandParams.put("rateY", colorControlmoveColorrateYCommandParameterInfo); + + CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveColorCommandParams.put( + "optionsMask", colorControlmoveColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveColorCommandParams.put( + "optionsOverride", colorControlmoveColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveColorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveColor( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("rateX"), + (Integer) commandArguments.get("rateY"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveColorCommandParams); + colorControlClusterInteractionInfoMap.put("moveColor", colorControlmoveColorInteractionInfo); + Map colorControlmoveColorTemperatureCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "moveMode", colorControlmoveColorTemperaturemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "rate", colorControlmoveColorTemperaturerateCommandParameterInfo); + + CommandParameterInfo + colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMinimum", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "colorTemperatureMinimum", + colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); + + CommandParameterInfo + colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMaximum", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "colorTemperatureMaximum", + colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "optionsMask", colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "optionsOverride", colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveColorTemperatureInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveColorTemperature( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("colorTemperatureMinimum"), + (Integer) commandArguments.get("colorTemperatureMaximum"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveColorTemperatureCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveColorTemperature", colorControlmoveColorTemperatureInteractionInfo); + Map colorControlmoveHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveHueCommandParams.put( + "moveMode", colorControlmoveHuemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlmoveHueCommandParams.put("rate", colorControlmoveHuerateCommandParameterInfo); + + CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveHueCommandParams.put( + "optionsMask", colorControlmoveHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveHueCommandParams.put( + "optionsOverride", colorControlmoveHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveHueCommandParams); + colorControlClusterInteractionInfoMap.put("moveHue", colorControlmoveHueInteractionInfo); + Map colorControlmoveSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveSaturationCommandParams.put( + "moveMode", colorControlmoveSaturationmoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlmoveSaturationCommandParams.put( + "rate", colorControlmoveSaturationrateCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveSaturationCommandParams.put( + "optionsMask", colorControlmoveSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveSaturationCommandParams.put( + "optionsOverride", colorControlmoveSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveSaturation", colorControlmoveSaturationInteractionInfo); + Map colorControlmoveToColorCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = + new CommandParameterInfo("colorX", Integer.class); + colorControlmoveToColorCommandParams.put( + "colorX", colorControlmoveToColorcolorXCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = + new CommandParameterInfo("colorY", Integer.class); + colorControlmoveToColorCommandParams.put( + "colorY", colorControlmoveToColorcolorYCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToColorCommandParams.put( + "transitionTime", colorControlmoveToColortransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToColorCommandParams.put( + "optionsMask", colorControlmoveToColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToColorCommandParams.put( + "optionsOverride", colorControlmoveToColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToColorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToColor( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("colorX"), + (Integer) commandArguments.get("colorY"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToColorCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToColor", colorControlmoveToColorInteractionInfo); + Map colorControlmoveToColorTemperatureCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = + new CommandParameterInfo("colorTemperature", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "colorTemperature", colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "transitionTime", colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "optionsMask", colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "optionsOverride", colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToColorTemperature( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("colorTemperature"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToColorTemperatureCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToColorTemperature", colorControlmoveToColorTemperatureInteractionInfo); + Map colorControlmoveToHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = + new CommandParameterInfo("hue", Integer.class); + colorControlmoveToHueCommandParams.put("hue", colorControlmoveToHuehueCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = + new CommandParameterInfo("direction", Integer.class); + colorControlmoveToHueCommandParams.put( + "direction", colorControlmoveToHuedirectionCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToHueCommandParams.put( + "transitionTime", colorControlmoveToHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToHueCommandParams.put( + "optionsMask", colorControlmoveToHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToHueCommandParams.put( + "optionsOverride", colorControlmoveToHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("hue"), + (Integer) commandArguments.get("direction"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToHueCommandParams); + colorControlClusterInteractionInfoMap.put("moveToHue", colorControlmoveToHueInteractionInfo); + Map colorControlmoveToHueAndSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = + new CommandParameterInfo("hue", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "hue", colorControlmoveToHueAndSaturationhueCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = + new CommandParameterInfo("saturation", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "saturation", colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "transitionTime", colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "optionsMask", colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "optionsOverride", colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToHueAndSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("hue"), + (Integer) commandArguments.get("saturation"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToHueAndSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToHueAndSaturation", colorControlmoveToHueAndSaturationInteractionInfo); + Map colorControlmoveToSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = + new CommandParameterInfo("saturation", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "saturation", colorControlmoveToSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "transitionTime", colorControlmoveToSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "optionsMask", colorControlmoveToSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "optionsOverride", colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("saturation"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToSaturation", colorControlmoveToSaturationInteractionInfo); + Map colorControlstepColorCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = + new CommandParameterInfo("stepX", Integer.class); + colorControlstepColorCommandParams.put("stepX", colorControlstepColorstepXCommandParameterInfo); + + CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = + new CommandParameterInfo("stepY", Integer.class); + colorControlstepColorCommandParams.put("stepY", colorControlstepColorstepYCommandParameterInfo); + + CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepColorCommandParams.put( + "transitionTime", colorControlstepColortransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepColorCommandParams.put( + "optionsMask", colorControlstepColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepColorCommandParams.put( + "optionsOverride", colorControlstepColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepColorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepColor( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepX"), + (Integer) commandArguments.get("stepY"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepColorCommandParams); + colorControlClusterInteractionInfoMap.put("stepColor", colorControlstepColorInteractionInfo); + Map colorControlstepColorTemperatureCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "stepMode", colorControlstepColorTemperaturestepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "stepSize", colorControlstepColorTemperaturestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "transitionTime", colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); + + CommandParameterInfo + colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMinimum", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "colorTemperatureMinimum", + colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); + + CommandParameterInfo + colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMaximum", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "colorTemperatureMaximum", + colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "optionsMask", colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "optionsOverride", colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepColorTemperatureInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepColorTemperature( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("colorTemperatureMinimum"), + (Integer) commandArguments.get("colorTemperatureMaximum"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepColorTemperatureCommandParams); + colorControlClusterInteractionInfoMap.put( + "stepColorTemperature", colorControlstepColorTemperatureInteractionInfo); + Map colorControlstepHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlstepHueCommandParams.put( + "stepMode", colorControlstepHuestepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlstepHueCommandParams.put( + "stepSize", colorControlstepHuestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepHueCommandParams.put( + "transitionTime", colorControlstepHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepHueCommandParams.put( + "optionsMask", colorControlstepHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepHueCommandParams.put( + "optionsOverride", colorControlstepHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepHueCommandParams); + colorControlClusterInteractionInfoMap.put("stepHue", colorControlstepHueInteractionInfo); + Map colorControlstepSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlstepSaturationCommandParams.put( + "stepMode", colorControlstepSaturationstepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlstepSaturationCommandParams.put( + "stepSize", colorControlstepSaturationstepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepSaturationCommandParams.put( + "transitionTime", colorControlstepSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepSaturationCommandParams.put( + "optionsMask", colorControlstepSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepSaturationCommandParams.put( + "optionsOverride", colorControlstepSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "stepSaturation", colorControlstepSaturationInteractionInfo); + Map colorControlstopMoveStepCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstopMoveStepCommandParams.put( + "optionsMask", colorControlstopMoveStepoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstopMoveStepCommandParams.put( + "optionsOverride", colorControlstopMoveStepoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstopMoveStepInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stopMoveStep( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstopMoveStepCommandParams); + colorControlClusterInteractionInfoMap.put( + "stopMoveStep", colorControlstopMoveStepInteractionInfo); + commandMap.put("colorControl", colorControlClusterInteractionInfoMap); + Map contentLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); + Map contentLauncherlaunchContentRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = + new CommandParameterInfo("autoPlay", Boolean.class); + contentLauncherlaunchContentRequestCommandParams.put( + "autoPlay", contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); + + CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = + new CommandParameterInfo("data", String.class); + contentLauncherlaunchContentRequestCommandParams.put( + "data", contentLauncherlaunchContentRequestdataCommandParameterInfo); + + InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .launchContentRequest( + (ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback, + (Boolean) commandArguments.get("autoPlay"), + (String) commandArguments.get("data"), + (ArrayList) + commandArguments.get("search")); + }, + () -> new DelegatedLaunchResponseCallback(), + contentLauncherlaunchContentRequestCommandParams); + contentLauncherClusterInteractionInfoMap.put( + "launchContentRequest", contentLauncherlaunchContentRequestInteractionInfo); + Map contentLauncherlaunchURLRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = + new CommandParameterInfo("contentURL", String.class); + contentLauncherlaunchURLRequestCommandParams.put( + "contentURL", contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); + + CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = + new CommandParameterInfo("displayString", String.class); + contentLauncherlaunchURLRequestCommandParams.put( + "displayString", contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); + + InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .launchURLRequest( + (ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback, + (String) commandArguments.get("contentURL"), + (String) commandArguments.get("displayString"), + (ChipStructs.ContentLauncherClusterBrandingInformation) + commandArguments.get("brandingInformation")); + }, + () -> new DelegatedLaunchResponseCallback(), + contentLauncherlaunchURLRequestCommandParams); + contentLauncherClusterInteractionInfoMap.put( + "launchURLRequest", contentLauncherlaunchURLRequestInteractionInfo); + commandMap.put("contentLauncher", contentLauncherClusterInteractionInfoMap); + Map descriptorClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("descriptor", descriptorClusterInteractionInfoMap); + Map diagnosticLogsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map diagnosticLogsretrieveLogsRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = + new CommandParameterInfo("intent", Integer.class); + diagnosticLogsretrieveLogsRequestCommandParams.put( + "intent", diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); + + CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = + new CommandParameterInfo("requestedProtocol", Integer.class); + diagnosticLogsretrieveLogsRequestCommandParams.put( + "requestedProtocol", + diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); + + CommandParameterInfo + diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = + new CommandParameterInfo("transferFileDesignator", byte[].class); + diagnosticLogsretrieveLogsRequestCommandParams.put( + "transferFileDesignator", + diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); + + InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .retrieveLogsRequest( + (ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback) callback, + (Integer) commandArguments.get("intent"), + (Integer) commandArguments.get("requestedProtocol"), + (byte[]) commandArguments.get("transferFileDesignator")); + }, + () -> new DelegatedRetrieveLogsResponseCallback(), + diagnosticLogsretrieveLogsRequestCommandParams); + diagnosticLogsClusterInteractionInfoMap.put( + "retrieveLogsRequest", diagnosticLogsretrieveLogsRequestInteractionInfo); + commandMap.put("diagnosticLogs", diagnosticLogsClusterInteractionInfoMap); + Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); + Map doorLockclearCredentialCommandParams = + new LinkedHashMap(); + InteractionInfo doorLockclearCredentialInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearCredential( + (DefaultClusterCallback) callback, + (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearCredentialCommandParams); + doorLockClusterInteractionInfoMap.put( + "clearCredential", doorLockclearCredentialInteractionInfo); + Map doorLockclearUserCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockclearUserCommandParams.put("userIndex", doorLockclearUseruserIndexCommandParameterInfo); + + InteractionInfo doorLockclearUserInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearUser( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("userIndex"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearUserCommandParams); + doorLockClusterInteractionInfoMap.put("clearUser", doorLockclearUserInteractionInfo); + Map doorLockclearWeekDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = + new CommandParameterInfo("weekDayIndex", Integer.class); + doorLockclearWeekDayScheduleCommandParams.put( + "weekDayIndex", doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockclearWeekDayScheduleCommandParams.put( + "userIndex", doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearWeekDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("weekDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearWeekDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "clearWeekDaySchedule", doorLockclearWeekDayScheduleInteractionInfo); + Map doorLockclearYearDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = + new CommandParameterInfo("yearDayIndex", Integer.class); + doorLockclearYearDayScheduleCommandParams.put( + "yearDayIndex", doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockclearYearDayScheduleCommandParams.put( + "userIndex", doorLockclearYearDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockclearYearDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearYearDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("yearDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearYearDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "clearYearDaySchedule", doorLockclearYearDayScheduleInteractionInfo); + Map doorLockgetCredentialStatusCommandParams = + new LinkedHashMap(); + InteractionInfo doorLockgetCredentialStatusInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getCredentialStatus( + (ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback, + (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential")); + }, + () -> new DelegatedGetCredentialStatusResponseCallback(), + doorLockgetCredentialStatusCommandParams); + doorLockClusterInteractionInfoMap.put( + "getCredentialStatus", doorLockgetCredentialStatusInteractionInfo); + Map doorLockgetUserCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockgetUserCommandParams.put("userIndex", doorLockgetUseruserIndexCommandParameterInfo); + + InteractionInfo doorLockgetUserInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getUser( + (ChipClusters.DoorLockCluster.GetUserResponseCallback) callback, + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedGetUserResponseCallback(), + doorLockgetUserCommandParams); + doorLockClusterInteractionInfoMap.put("getUser", doorLockgetUserInteractionInfo); + Map doorLockgetWeekDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = + new CommandParameterInfo("weekDayIndex", Integer.class); + doorLockgetWeekDayScheduleCommandParams.put( + "weekDayIndex", doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockgetWeekDayScheduleCommandParams.put( + "userIndex", doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getWeekDaySchedule( + (ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback) callback, + (Integer) commandArguments.get("weekDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedGetWeekDayScheduleResponseCallback(), + doorLockgetWeekDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "getWeekDaySchedule", doorLockgetWeekDayScheduleInteractionInfo); + Map doorLockgetYearDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = + new CommandParameterInfo("yearDayIndex", Integer.class); + doorLockgetYearDayScheduleCommandParams.put( + "yearDayIndex", doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockgetYearDayScheduleCommandParams.put( + "userIndex", doorLockgetYearDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockgetYearDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getYearDaySchedule( + (ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback) callback, + (Integer) commandArguments.get("yearDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedGetYearDayScheduleResponseCallback(), + doorLockgetYearDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "getYearDaySchedule", doorLockgetYearDayScheduleInteractionInfo); + Map doorLocklockDoorCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = + new CommandParameterInfo("pinCode", Optional.class); + doorLocklockDoorCommandParams.put("pinCode", doorLocklockDoorpinCodeCommandParameterInfo); + + InteractionInfo doorLocklockDoorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .lockDoor( + (DefaultClusterCallback) callback, + (Optional) commandArguments.get("pinCode"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocklockDoorCommandParams); + doorLockClusterInteractionInfoMap.put("lockDoor", doorLocklockDoorInteractionInfo); + Map doorLocksetCredentialCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = + new CommandParameterInfo("operationType", Integer.class); + doorLocksetCredentialCommandParams.put( + "operationType", doorLocksetCredentialoperationTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = + new CommandParameterInfo("credentialData", byte[].class); + doorLocksetCredentialCommandParams.put( + "credentialData", doorLocksetCredentialcredentialDataCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetCredentialCommandParams.put( + "userIndex", doorLocksetCredentialuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = + new CommandParameterInfo("userStatus", Integer.class); + doorLocksetCredentialCommandParams.put( + "userStatus", doorLocksetCredentialuserStatusCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = + new CommandParameterInfo("userType", Integer.class); + doorLocksetCredentialCommandParams.put( + "userType", doorLocksetCredentialuserTypeCommandParameterInfo); + + InteractionInfo doorLocksetCredentialInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setCredential( + (ChipClusters.DoorLockCluster.SetCredentialResponseCallback) callback, + (Integer) commandArguments.get("operationType"), + (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential"), + (byte[]) commandArguments.get("credentialData"), + (Integer) commandArguments.get("userIndex"), + (Integer) commandArguments.get("userStatus"), + (Integer) commandArguments.get("userType"), + 10000); + }, + () -> new DelegatedSetCredentialResponseCallback(), + doorLocksetCredentialCommandParams); + doorLockClusterInteractionInfoMap.put("setCredential", doorLocksetCredentialInteractionInfo); + Map doorLocksetUserCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = + new CommandParameterInfo("operationType", Integer.class); + doorLocksetUserCommandParams.put( + "operationType", doorLocksetUseroperationTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetUserCommandParams.put("userIndex", doorLocksetUseruserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = + new CommandParameterInfo("userName", String.class); + doorLocksetUserCommandParams.put("userName", doorLocksetUseruserNameCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = + new CommandParameterInfo("userUniqueId", Long.class); + doorLocksetUserCommandParams.put( + "userUniqueId", doorLocksetUseruserUniqueIdCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = + new CommandParameterInfo("userStatus", Integer.class); + doorLocksetUserCommandParams.put("userStatus", doorLocksetUseruserStatusCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = + new CommandParameterInfo("userType", Integer.class); + doorLocksetUserCommandParams.put("userType", doorLocksetUseruserTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = + new CommandParameterInfo("credentialRule", Integer.class); + doorLocksetUserCommandParams.put( + "credentialRule", doorLocksetUsercredentialRuleCommandParameterInfo); + + InteractionInfo doorLocksetUserInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setUser( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("operationType"), + (Integer) commandArguments.get("userIndex"), + (String) commandArguments.get("userName"), + (Long) commandArguments.get("userUniqueId"), + (Integer) commandArguments.get("userStatus"), + (Integer) commandArguments.get("userType"), + (Integer) commandArguments.get("credentialRule"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetUserCommandParams); + doorLockClusterInteractionInfoMap.put("setUser", doorLocksetUserInteractionInfo); + Map doorLocksetWeekDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = + new CommandParameterInfo("weekDayIndex", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "weekDayIndex", doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "userIndex", doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = + new CommandParameterInfo("daysMask", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "daysMask", doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = + new CommandParameterInfo("startHour", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "startHour", doorLocksetWeekDaySchedulestartHourCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = + new CommandParameterInfo("startMinute", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "startMinute", doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = + new CommandParameterInfo("endHour", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "endHour", doorLocksetWeekDayScheduleendHourCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = + new CommandParameterInfo("endMinute", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "endMinute", doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); + + InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setWeekDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("weekDayIndex"), + (Integer) commandArguments.get("userIndex"), + (Integer) commandArguments.get("daysMask"), + (Integer) commandArguments.get("startHour"), + (Integer) commandArguments.get("startMinute"), + (Integer) commandArguments.get("endHour"), + (Integer) commandArguments.get("endMinute")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetWeekDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "setWeekDaySchedule", doorLocksetWeekDayScheduleInteractionInfo); + Map doorLocksetYearDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = + new CommandParameterInfo("yearDayIndex", Integer.class); + doorLocksetYearDayScheduleCommandParams.put( + "yearDayIndex", doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetYearDayScheduleCommandParams.put( + "userIndex", doorLocksetYearDayScheduleuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = + new CommandParameterInfo("localStartTime", Long.class); + doorLocksetYearDayScheduleCommandParams.put( + "localStartTime", doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = + new CommandParameterInfo("localEndTime", Long.class); + doorLocksetYearDayScheduleCommandParams.put( + "localEndTime", doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); + + InteractionInfo doorLocksetYearDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setYearDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("yearDayIndex"), + (Integer) commandArguments.get("userIndex"), + (Long) commandArguments.get("localStartTime"), + (Long) commandArguments.get("localEndTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetYearDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "setYearDaySchedule", doorLocksetYearDayScheduleInteractionInfo); + Map doorLockunlockDoorCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = + new CommandParameterInfo("pinCode", Optional.class); + doorLockunlockDoorCommandParams.put("pinCode", doorLockunlockDoorpinCodeCommandParameterInfo); + + InteractionInfo doorLockunlockDoorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .unlockDoor( + (DefaultClusterCallback) callback, + (Optional) commandArguments.get("pinCode"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockunlockDoorCommandParams); + doorLockClusterInteractionInfoMap.put("unlockDoor", doorLockunlockDoorInteractionInfo); + Map doorLockunlockWithTimeoutCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = + new CommandParameterInfo("timeout", Integer.class); + doorLockunlockWithTimeoutCommandParams.put( + "timeout", doorLockunlockWithTimeouttimeoutCommandParameterInfo); + + CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = + new CommandParameterInfo("pinCode", Optional.class); + doorLockunlockWithTimeoutCommandParams.put( + "pinCode", doorLockunlockWithTimeoutpinCodeCommandParameterInfo); + + InteractionInfo doorLockunlockWithTimeoutInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .unlockWithTimeout( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("timeout"), + (Optional) commandArguments.get("pinCode"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockunlockWithTimeoutCommandParams); + doorLockClusterInteractionInfoMap.put( + "unlockWithTimeout", doorLockunlockWithTimeoutInteractionInfo); + commandMap.put("doorLock", doorLockClusterInteractionInfoMap); + Map electricalMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("electricalMeasurement", electricalMeasurementClusterInteractionInfoMap); + Map ethernetNetworkDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map ethernetNetworkDiagnosticsresetCountsCommandParams = + new LinkedHashMap(); + InteractionInfo ethernetNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + ethernetNetworkDiagnosticsresetCountsCommandParams); + ethernetNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", ethernetNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put( + "ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); + Map fixedLabelClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("fixedLabel", fixedLabelClusterInteractionInfoMap); + Map flowMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("flowMeasurement", flowMeasurementClusterInteractionInfoMap); + Map generalCommissioningClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map generalCommissioningarmFailSafeCommandParams = + new LinkedHashMap(); + CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = + new CommandParameterInfo("expiryLengthSeconds", Integer.class); + generalCommissioningarmFailSafeCommandParams.put( + "expiryLengthSeconds", + generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); + + CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + generalCommissioningarmFailSafeCommandParams.put( + "breadcrumb", generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); + + CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = + new CommandParameterInfo("timeoutMs", Long.class); + generalCommissioningarmFailSafeCommandParams.put( + "timeoutMs", generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); + + InteractionInfo generalCommissioningarmFailSafeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .armFailSafe( + (ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback) + callback, + (Integer) commandArguments.get("expiryLengthSeconds"), + (Long) commandArguments.get("breadcrumb"), + (Long) commandArguments.get("timeoutMs")); + }, + () -> new DelegatedArmFailSafeResponseCallback(), + generalCommissioningarmFailSafeCommandParams); + generalCommissioningClusterInteractionInfoMap.put( + "armFailSafe", generalCommissioningarmFailSafeInteractionInfo); + Map generalCommissioningcommissioningCompleteCommandParams = + new LinkedHashMap(); + InteractionInfo generalCommissioningcommissioningCompleteInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .commissioningComplete( + (ChipClusters.GeneralCommissioningCluster + .CommissioningCompleteResponseCallback) + callback); + }, + () -> new DelegatedCommissioningCompleteResponseCallback(), + generalCommissioningcommissioningCompleteCommandParams); + generalCommissioningClusterInteractionInfoMap.put( + "commissioningComplete", generalCommissioningcommissioningCompleteInteractionInfo); + Map generalCommissioningsetRegulatoryConfigCommandParams = + new LinkedHashMap(); + CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = + new CommandParameterInfo("location", Integer.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "location", generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = + new CommandParameterInfo("countryCode", String.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "countryCode", generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "breadcrumb", generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = + new CommandParameterInfo("timeoutMs", Long.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "timeoutMs", generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); + + InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .setRegulatoryConfig( + (ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback) + callback, + (Integer) commandArguments.get("location"), + (String) commandArguments.get("countryCode"), + (Long) commandArguments.get("breadcrumb"), + (Long) commandArguments.get("timeoutMs")); + }, + () -> new DelegatedSetRegulatoryConfigResponseCallback(), + generalCommissioningsetRegulatoryConfigCommandParams); + generalCommissioningClusterInteractionInfoMap.put( + "setRegulatoryConfig", generalCommissioningsetRegulatoryConfigInteractionInfo); + commandMap.put("generalCommissioning", generalCommissioningClusterInteractionInfoMap); + Map generalDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("generalDiagnostics", generalDiagnosticsClusterInteractionInfoMap); + Map groupKeyManagementClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map groupKeyManagementkeySetReadCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = + new CommandParameterInfo("groupKeySetID", Integer.class); + groupKeyManagementkeySetReadCommandParams.put( + "groupKeySetID", groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetReadInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetRead( + (ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback, + (Integer) commandArguments.get("groupKeySetID")); + }, + () -> new DelegatedKeySetReadResponseCallback(), + groupKeyManagementkeySetReadCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetRead", groupKeyManagementkeySetReadInteractionInfo); + Map groupKeyManagementkeySetReadAllIndicesCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = + new CommandParameterInfo("groupKeySetIDs", ArrayList.class); + groupKeyManagementkeySetReadAllIndicesCommandParams.put( + "groupKeySetIDs", groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetReadAllIndices( + (ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) + callback, + (ArrayList) commandArguments.get("groupKeySetIDs")); + }, + () -> new DelegatedKeySetReadAllIndicesResponseCallback(), + groupKeyManagementkeySetReadAllIndicesCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetReadAllIndices", groupKeyManagementkeySetReadAllIndicesInteractionInfo); + Map groupKeyManagementkeySetRemoveCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = + new CommandParameterInfo("groupKeySetID", Integer.class); + groupKeyManagementkeySetRemoveCommandParams.put( + "groupKeySetID", groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetRemove( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("groupKeySetID")); + }, + () -> new DelegatedDefaultClusterCallback(), + groupKeyManagementkeySetRemoveCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetRemove", groupKeyManagementkeySetRemoveInteractionInfo); + Map groupKeyManagementkeySetWriteCommandParams = + new LinkedHashMap(); + InteractionInfo groupKeyManagementkeySetWriteInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetWrite( + (DefaultClusterCallback) callback, + (ChipStructs.GroupKeyManagementClusterGroupKeySet) + commandArguments.get("groupKeySet")); + }, + () -> new DelegatedDefaultClusterCallback(), + groupKeyManagementkeySetWriteCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetWrite", groupKeyManagementkeySetWriteInteractionInfo); + commandMap.put("groupKeyManagement", groupKeyManagementClusterInteractionInfoMap); + Map groupsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map groupsaddGroupCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsaddGroupCommandParams.put("groupId", groupsaddGroupgroupIdCommandParameterInfo); + + CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = + new CommandParameterInfo("groupName", String.class); + groupsaddGroupCommandParams.put("groupName", groupsaddGroupgroupNameCommandParameterInfo); + + InteractionInfo groupsaddGroupInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .addGroup( + (ChipClusters.GroupsCluster.AddGroupResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (String) commandArguments.get("groupName")); + }, + () -> new DelegatedAddGroupResponseCallback(), + groupsaddGroupCommandParams); + groupsClusterInteractionInfoMap.put("addGroup", groupsaddGroupInteractionInfo); + Map groupsaddGroupIfIdentifyingCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsaddGroupIfIdentifyingCommandParams.put( + "groupId", groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); + + CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = + new CommandParameterInfo("groupName", String.class); + groupsaddGroupIfIdentifyingCommandParams.put( + "groupName", groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); + + InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .addGroupIfIdentifying( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("groupId"), + (String) commandArguments.get("groupName")); + }, + () -> new DelegatedDefaultClusterCallback(), + groupsaddGroupIfIdentifyingCommandParams); + groupsClusterInteractionInfoMap.put( + "addGroupIfIdentifying", groupsaddGroupIfIdentifyingInteractionInfo); + Map groupsgetGroupMembershipCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = + new CommandParameterInfo("groupList", ArrayList.class); + groupsgetGroupMembershipCommandParams.put( + "groupList", groupsgetGroupMembershipgroupListCommandParameterInfo); + + InteractionInfo groupsgetGroupMembershipInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .getGroupMembership( + (ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback, + (ArrayList) commandArguments.get("groupList")); + }, + () -> new DelegatedGetGroupMembershipResponseCallback(), + groupsgetGroupMembershipCommandParams); + groupsClusterInteractionInfoMap.put( + "getGroupMembership", groupsgetGroupMembershipInteractionInfo); + Map groupsremoveAllGroupsCommandParams = + new LinkedHashMap(); + InteractionInfo groupsremoveAllGroupsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .removeAllGroups((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + groupsremoveAllGroupsCommandParams); + groupsClusterInteractionInfoMap.put("removeAllGroups", groupsremoveAllGroupsInteractionInfo); + Map groupsremoveGroupCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsremoveGroupCommandParams.put("groupId", groupsremoveGroupgroupIdCommandParameterInfo); + + InteractionInfo groupsremoveGroupInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .removeGroup( + (ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedRemoveGroupResponseCallback(), + groupsremoveGroupCommandParams); + groupsClusterInteractionInfoMap.put("removeGroup", groupsremoveGroupInteractionInfo); + Map groupsviewGroupCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsviewGroupCommandParams.put("groupId", groupsviewGroupgroupIdCommandParameterInfo); + + InteractionInfo groupsviewGroupInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .viewGroup( + (ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedViewGroupResponseCallback(), + groupsviewGroupCommandParams); + groupsClusterInteractionInfoMap.put("viewGroup", groupsviewGroupInteractionInfo); + commandMap.put("groups", groupsClusterInteractionInfoMap); + Map identifyClusterInteractionInfoMap = new LinkedHashMap<>(); + Map identifyidentifyCommandParams = + new LinkedHashMap(); + CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = + new CommandParameterInfo("identifyTime", Integer.class); + identifyidentifyCommandParams.put( + "identifyTime", identifyidentifyidentifyTimeCommandParameterInfo); + + InteractionInfo identifyidentifyInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .identify( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("identifyTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + identifyidentifyCommandParams); + identifyClusterInteractionInfoMap.put("identify", identifyidentifyInteractionInfo); + Map identifyidentifyQueryCommandParams = + new LinkedHashMap(); + InteractionInfo identifyidentifyQueryInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .identifyQuery( + (ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback); + }, + () -> new DelegatedIdentifyQueryResponseCallback(), + identifyidentifyQueryCommandParams); + identifyClusterInteractionInfoMap.put("identifyQuery", identifyidentifyQueryInteractionInfo); + Map identifytriggerEffectCommandParams = + new LinkedHashMap(); + CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = + new CommandParameterInfo("effectIdentifier", Integer.class); + identifytriggerEffectCommandParams.put( + "effectIdentifier", identifytriggerEffecteffectIdentifierCommandParameterInfo); + + CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = + new CommandParameterInfo("effectVariant", Integer.class); + identifytriggerEffectCommandParams.put( + "effectVariant", identifytriggerEffecteffectVariantCommandParameterInfo); + + InteractionInfo identifytriggerEffectInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .triggerEffect( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("effectIdentifier"), + (Integer) commandArguments.get("effectVariant")); + }, + () -> new DelegatedDefaultClusterCallback(), + identifytriggerEffectCommandParams); + identifyClusterInteractionInfoMap.put("triggerEffect", identifytriggerEffectInteractionInfo); + commandMap.put("identify", identifyClusterInteractionInfoMap); + Map illuminanceMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInteractionInfoMap); + Map keypadInputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map keypadInputsendKeyRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = + new CommandParameterInfo("keyCode", Integer.class); + keypadInputsendKeyRequestCommandParams.put( + "keyCode", keypadInputsendKeyRequestkeyCodeCommandParameterInfo); + + InteractionInfo keypadInputsendKeyRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .sendKeyRequest( + (ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback, + (Integer) commandArguments.get("keyCode")); + }, + () -> new DelegatedSendKeyResponseCallback(), + keypadInputsendKeyRequestCommandParams); + keypadInputClusterInteractionInfoMap.put( + "sendKeyRequest", keypadInputsendKeyRequestInteractionInfo); + commandMap.put("keypadInput", keypadInputClusterInteractionInfoMap); + Map levelControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map levelControlmoveCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + levelControlmoveCommandParams.put("moveMode", levelControlmovemoveModeCommandParameterInfo); + + CommandParameterInfo levelControlmoverateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + levelControlmoveCommandParams.put("rate", levelControlmoverateCommandParameterInfo); + + CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlmoveCommandParams.put("optionMask", levelControlmoveoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlmoveCommandParams.put( + "optionOverride", levelControlmoveoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlmoveInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .move( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveCommandParams); + levelControlClusterInteractionInfoMap.put("move", levelControlmoveInteractionInfo); + Map levelControlmoveToLevelCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = + new CommandParameterInfo("level", Integer.class); + levelControlmoveToLevelCommandParams.put( + "level", levelControlmoveToLevellevelCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlmoveToLevelCommandParams.put( + "transitionTime", levelControlmoveToLeveltransitionTimeCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlmoveToLevelCommandParams.put( + "optionMask", levelControlmoveToLeveloptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlmoveToLevelCommandParams.put( + "optionOverride", levelControlmoveToLeveloptionOverrideCommandParameterInfo); + + InteractionInfo levelControlmoveToLevelInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveToLevel( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("level"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveToLevelCommandParams); + levelControlClusterInteractionInfoMap.put( + "moveToLevel", levelControlmoveToLevelInteractionInfo); + Map levelControlmoveToLevelWithOnOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = + new CommandParameterInfo("level", Integer.class); + levelControlmoveToLevelWithOnOffCommandParams.put( + "level", levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlmoveToLevelWithOnOffCommandParams.put( + "transitionTime", levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); + + InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveToLevelWithOnOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("level"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveToLevelWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffInteractionInfo); + Map levelControlmoveWithOnOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + levelControlmoveWithOnOffCommandParams.put( + "moveMode", levelControlmoveWithOnOffmoveModeCommandParameterInfo); + + CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + levelControlmoveWithOnOffCommandParams.put( + "rate", levelControlmoveWithOnOffrateCommandParameterInfo); + + InteractionInfo levelControlmoveWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveWithOnOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "moveWithOnOff", levelControlmoveWithOnOffInteractionInfo); + Map levelControlstepCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlstepstepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + levelControlstepCommandParams.put("stepMode", levelControlstepstepModeCommandParameterInfo); + + CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + levelControlstepCommandParams.put("stepSize", levelControlstepstepSizeCommandParameterInfo); + + CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlstepCommandParams.put( + "transitionTime", levelControlsteptransitionTimeCommandParameterInfo); + + CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlstepCommandParams.put("optionMask", levelControlstepoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlstepCommandParams.put( + "optionOverride", levelControlstepoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlstepInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .step( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstepCommandParams); + levelControlClusterInteractionInfoMap.put("step", levelControlstepInteractionInfo); + Map levelControlstepWithOnOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + levelControlstepWithOnOffCommandParams.put( + "stepMode", levelControlstepWithOnOffstepModeCommandParameterInfo); + + CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + levelControlstepWithOnOffCommandParams.put( + "stepSize", levelControlstepWithOnOffstepSizeCommandParameterInfo); + + CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlstepWithOnOffCommandParams.put( + "transitionTime", levelControlstepWithOnOfftransitionTimeCommandParameterInfo); + + InteractionInfo levelControlstepWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stepWithOnOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstepWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "stepWithOnOff", levelControlstepWithOnOffInteractionInfo); + Map levelControlstopCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlstopCommandParams.put("optionMask", levelControlstopoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlstopCommandParams.put( + "optionOverride", levelControlstopoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlstopInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stop( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstopCommandParams); + levelControlClusterInteractionInfoMap.put("stop", levelControlstopInteractionInfo); + Map levelControlstopWithOnOffCommandParams = + new LinkedHashMap(); + InteractionInfo levelControlstopWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stopWithOnOff((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstopWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "stopWithOnOff", levelControlstopWithOnOffInteractionInfo); + commandMap.put("levelControl", levelControlClusterInteractionInfoMap); + Map localizationConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("localizationConfiguration", localizationConfigurationClusterInteractionInfoMap); + Map lowPowerClusterInteractionInfoMap = new LinkedHashMap<>(); + Map lowPowersleepCommandParams = + new LinkedHashMap(); + InteractionInfo lowPowersleepInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).sleep((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + lowPowersleepCommandParams); + lowPowerClusterInteractionInfoMap.put("sleep", lowPowersleepInteractionInfo); + commandMap.put("lowPower", lowPowerClusterInteractionInfoMap); + Map mediaInputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map mediaInputhideInputStatusRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaInputhideInputStatusRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .hideInputStatusRequest((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputhideInputStatusRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "hideInputStatusRequest", mediaInputhideInputStatusRequestInteractionInfo); + Map mediaInputrenameInputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + mediaInputrenameInputRequestCommandParams.put( + "index", mediaInputrenameInputRequestindexCommandParameterInfo); + + CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = + new CommandParameterInfo("name", String.class); + mediaInputrenameInputRequestCommandParams.put( + "name", mediaInputrenameInputRequestnameCommandParameterInfo); + + InteractionInfo mediaInputrenameInputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .renameInputRequest( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("index"), + (String) commandArguments.get("name")); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputrenameInputRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "renameInputRequest", mediaInputrenameInputRequestInteractionInfo); + Map mediaInputselectInputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + mediaInputselectInputRequestCommandParams.put( + "index", mediaInputselectInputRequestindexCommandParameterInfo); + + InteractionInfo mediaInputselectInputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .selectInputRequest( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("index")); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputselectInputRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "selectInputRequest", mediaInputselectInputRequestInteractionInfo); + Map mediaInputshowInputStatusRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaInputshowInputStatusRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .showInputStatusRequest((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputshowInputStatusRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "showInputStatusRequest", mediaInputshowInputStatusRequestInteractionInfo); + commandMap.put("mediaInput", mediaInputClusterInteractionInfoMap); + Map mediaPlaybackClusterInteractionInfoMap = new LinkedHashMap<>(); + Map mediaPlaybackfastForwardRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackfastForwardRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .fastForwardRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackfastForwardRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "fastForwardRequest", mediaPlaybackfastForwardRequestInteractionInfo); + Map mediaPlaybacknextRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybacknextRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .nextRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybacknextRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "nextRequest", mediaPlaybacknextRequestInteractionInfo); + Map mediaPlaybackpauseRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackpauseRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .pauseRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackpauseRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "pauseRequest", mediaPlaybackpauseRequestInteractionInfo); + Map mediaPlaybackplayRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackplayRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .playRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackplayRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "playRequest", mediaPlaybackplayRequestInteractionInfo); + Map mediaPlaybackpreviousRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackpreviousRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .previousRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackpreviousRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "previousRequest", mediaPlaybackpreviousRequestInteractionInfo); + Map mediaPlaybackrewindRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackrewindRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .rewindRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackrewindRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "rewindRequest", mediaPlaybackrewindRequestInteractionInfo); + Map mediaPlaybackseekRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = + new CommandParameterInfo("position", Long.class); + mediaPlaybackseekRequestCommandParams.put( + "position", mediaPlaybackseekRequestpositionCommandParameterInfo); + + InteractionInfo mediaPlaybackseekRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .seekRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, + (Long) commandArguments.get("position")); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackseekRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "seekRequest", mediaPlaybackseekRequestInteractionInfo); + Map mediaPlaybackskipBackwardRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = + new CommandParameterInfo("deltaPositionMilliseconds", Long.class); + mediaPlaybackskipBackwardRequestCommandParams.put( + "deltaPositionMilliseconds", + mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); + + InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .skipBackwardRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, + (Long) commandArguments.get("deltaPositionMilliseconds")); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackskipBackwardRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "skipBackwardRequest", mediaPlaybackskipBackwardRequestInteractionInfo); + Map mediaPlaybackskipForwardRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = + new CommandParameterInfo("deltaPositionMilliseconds", Long.class); + mediaPlaybackskipForwardRequestCommandParams.put( + "deltaPositionMilliseconds", + mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); + + InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .skipForwardRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, + (Long) commandArguments.get("deltaPositionMilliseconds")); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackskipForwardRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "skipForwardRequest", mediaPlaybackskipForwardRequestInteractionInfo); + Map mediaPlaybackstartOverRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackstartOverRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .startOverRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackstartOverRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "startOverRequest", mediaPlaybackstartOverRequestInteractionInfo); + Map mediaPlaybackstopRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackstopRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .stopRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackstopRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "stopRequest", mediaPlaybackstopRequestInteractionInfo); + commandMap.put("mediaPlayback", mediaPlaybackClusterInteractionInfoMap); + Map modeSelectClusterInteractionInfoMap = new LinkedHashMap<>(); + Map modeSelectchangeToModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = + new CommandParameterInfo("newMode", Integer.class); + modeSelectchangeToModeCommandParams.put( + "newMode", modeSelectchangeToModenewModeCommandParameterInfo); + + InteractionInfo modeSelectchangeToModeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .changeToMode( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("newMode")); + }, + () -> new DelegatedDefaultClusterCallback(), + modeSelectchangeToModeCommandParams); + modeSelectClusterInteractionInfoMap.put("changeToMode", modeSelectchangeToModeInteractionInfo); + commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); + Map networkCommissioningClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo + networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = + new CommandParameterInfo("operationalDataset", byte[].class); + networkCommissioningaddOrUpdateThreadNetworkCommandParams.put( + "operationalDataset", + networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); + + CommandParameterInfo + networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningaddOrUpdateThreadNetworkCommandParams.put( + "breadcrumb", networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .addOrUpdateThreadNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("operationalDataset"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningaddOrUpdateThreadNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "addOrUpdateThreadNetwork", networkCommissioningaddOrUpdateThreadNetworkInteractionInfo); + Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = + new CommandParameterInfo("ssid", byte[].class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( + "ssid", networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = + new CommandParameterInfo("credentials", byte[].class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( + "credentials", networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( + "breadcrumb", networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .addOrUpdateWiFiNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("ssid"), + (byte[]) commandArguments.get("credentials"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningaddOrUpdateWiFiNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "addOrUpdateWiFiNetwork", networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo); + Map networkCommissioningconnectNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = + new CommandParameterInfo("networkID", byte[].class); + networkCommissioningconnectNetworkCommandParams.put( + "networkID", networkCommissioningconnectNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningconnectNetworkCommandParams.put( + "breadcrumb", networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningconnectNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .connectNetwork( + (ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback) + callback, + (byte[]) commandArguments.get("networkID"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedConnectNetworkResponseCallback(), + networkCommissioningconnectNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "connectNetwork", networkCommissioningconnectNetworkInteractionInfo); + Map networkCommissioningremoveNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = + new CommandParameterInfo("networkID", byte[].class); + networkCommissioningremoveNetworkCommandParams.put( + "networkID", networkCommissioningremoveNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningremoveNetworkCommandParams.put( + "breadcrumb", networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningremoveNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .removeNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("networkID"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningremoveNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "removeNetwork", networkCommissioningremoveNetworkInteractionInfo); + Map networkCommissioningreorderNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = + new CommandParameterInfo("networkID", byte[].class); + networkCommissioningreorderNetworkCommandParams.put( + "networkID", networkCommissioningreorderNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = + new CommandParameterInfo("networkIndex", Integer.class); + networkCommissioningreorderNetworkCommandParams.put( + "networkIndex", networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); + + CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningreorderNetworkCommandParams.put( + "breadcrumb", networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningreorderNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .reorderNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("networkID"), + (Integer) commandArguments.get("networkIndex"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningreorderNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "reorderNetwork", networkCommissioningreorderNetworkInteractionInfo); + Map networkCommissioningscanNetworksCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = + new CommandParameterInfo("ssid", byte[].class); + networkCommissioningscanNetworksCommandParams.put( + "ssid", networkCommissioningscanNetworksssidCommandParameterInfo); + + CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningscanNetworksCommandParams.put( + "breadcrumb", networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningscanNetworksInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .scanNetworks( + (ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback) + callback, + (byte[]) commandArguments.get("ssid"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedScanNetworksResponseCallback(), + networkCommissioningscanNetworksCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "scanNetworks", networkCommissioningscanNetworksInteractionInfo); + commandMap.put("networkCommissioning", networkCommissioningClusterInteractionInfoMap); + Map otaSoftwareUpdateProviderClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = + new CommandParameterInfo("updateToken", byte[].class); + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put( + "updateToken", otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = + new CommandParameterInfo("newVersion", Long.class); + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put( + "newVersion", otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .applyUpdateRequest( + (ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback) + callback, + (byte[]) commandArguments.get("updateToken"), + (Long) commandArguments.get("newVersion")); + }, + () -> new DelegatedApplyUpdateResponseCallback(), + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo); + Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = + new LinkedHashMap(); + CommandParameterInfo + otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = + new CommandParameterInfo("updateToken", byte[].class); + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put( + "updateToken", otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = + new CommandParameterInfo("softwareVersion", Long.class); + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put( + "softwareVersion", + otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .notifyUpdateApplied( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("updateToken"), + (Long) commandArguments.get("softwareVersion")); + }, + () -> new DelegatedDefaultClusterCallback(), + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo); + Map otaSoftwareUpdateProviderqueryImageCommandParams = + new LinkedHashMap(); + CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = + new CommandParameterInfo("vendorId", Integer.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "vendorId", otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = + new CommandParameterInfo("productId", Integer.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "productId", otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = + new CommandParameterInfo("softwareVersion", Long.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "softwareVersion", otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = + new CommandParameterInfo("protocolsSupported", ArrayList.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "protocolsSupported", + otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = + new CommandParameterInfo("hardwareVersion", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "hardwareVersion", otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = + new CommandParameterInfo("location", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "location", otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = + new CommandParameterInfo("requestorCanConsent", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "requestorCanConsent", + otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = + new CommandParameterInfo("metadataForProvider", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "metadataForProvider", + otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .queryImage( + (ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback) + callback, + (Integer) commandArguments.get("vendorId"), + (Integer) commandArguments.get("productId"), + (Long) commandArguments.get("softwareVersion"), + (ArrayList) commandArguments.get("protocolsSupported"), + (Optional) commandArguments.get("hardwareVersion"), + (Optional) commandArguments.get("location"), + (Optional) commandArguments.get("requestorCanConsent"), + (Optional) commandArguments.get("metadataForProvider")); + }, + () -> new DelegatedQueryImageResponseCallback(), + otaSoftwareUpdateProviderqueryImageCommandParams); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "queryImage", otaSoftwareUpdateProviderqueryImageInteractionInfo); + commandMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInteractionInfoMap); + Map otaSoftwareUpdateRequestorClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = + new LinkedHashMap(); + CommandParameterInfo + otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = + new CommandParameterInfo("providerNodeId", Long.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "providerNodeId", + otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = + new CommandParameterInfo("vendorId", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "vendorId", otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = + new CommandParameterInfo("announcementReason", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "announcementReason", + otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = + new CommandParameterInfo("metadataForNode", Optional.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "metadataForNode", + otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = + new CommandParameterInfo("endpoint", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "endpoint", otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .announceOtaProvider( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("providerNodeId"), + (Integer) commandArguments.get("vendorId"), + (Integer) commandArguments.get("announcementReason"), + (Optional) commandArguments.get("metadataForNode"), + (Integer) commandArguments.get("endpoint")); + }, + () -> new DelegatedDefaultClusterCallback(), + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams); + otaSoftwareUpdateRequestorClusterInteractionInfoMap.put( + "announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo); + commandMap.put( + "otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInteractionInfoMap); + Map occupancySensingClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("occupancySensing", occupancySensingClusterInteractionInfoMap); + Map onOffClusterInteractionInfoMap = new LinkedHashMap<>(); + Map onOffoffCommandParams = + new LinkedHashMap(); + InteractionInfo onOffoffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).off((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffoffCommandParams); + onOffClusterInteractionInfoMap.put("off", onOffoffInteractionInfo); + Map onOffoffWithEffectCommandParams = + new LinkedHashMap(); + CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = + new CommandParameterInfo("effectId", Integer.class); + onOffoffWithEffectCommandParams.put("effectId", onOffoffWithEffecteffectIdCommandParameterInfo); + + CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = + new CommandParameterInfo("effectVariant", Integer.class); + onOffoffWithEffectCommandParams.put( + "effectVariant", onOffoffWithEffecteffectVariantCommandParameterInfo); + + InteractionInfo onOffoffWithEffectInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .offWithEffect( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("effectId"), + (Integer) commandArguments.get("effectVariant")); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffoffWithEffectCommandParams); + onOffClusterInteractionInfoMap.put("offWithEffect", onOffoffWithEffectInteractionInfo); + Map onOffonCommandParams = + new LinkedHashMap(); + InteractionInfo onOffonInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).on((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonCommandParams); + onOffClusterInteractionInfoMap.put("on", onOffonInteractionInfo); + Map onOffonWithRecallGlobalSceneCommandParams = + new LinkedHashMap(); + InteractionInfo onOffonWithRecallGlobalSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .onWithRecallGlobalScene((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonWithRecallGlobalSceneCommandParams); + onOffClusterInteractionInfoMap.put( + "onWithRecallGlobalScene", onOffonWithRecallGlobalSceneInteractionInfo); + Map onOffonWithTimedOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = + new CommandParameterInfo("onOffControl", Integer.class); + onOffonWithTimedOffCommandParams.put( + "onOffControl", onOffonWithTimedOffonOffControlCommandParameterInfo); + + CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = + new CommandParameterInfo("onTime", Integer.class); + onOffonWithTimedOffCommandParams.put("onTime", onOffonWithTimedOffonTimeCommandParameterInfo); + + CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = + new CommandParameterInfo("offWaitTime", Integer.class); + onOffonWithTimedOffCommandParams.put( + "offWaitTime", onOffonWithTimedOffoffWaitTimeCommandParameterInfo); + + InteractionInfo onOffonWithTimedOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .onWithTimedOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("onOffControl"), + (Integer) commandArguments.get("onTime"), + (Integer) commandArguments.get("offWaitTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonWithTimedOffCommandParams); + onOffClusterInteractionInfoMap.put("onWithTimedOff", onOffonWithTimedOffInteractionInfo); + Map onOfftoggleCommandParams = + new LinkedHashMap(); + InteractionInfo onOfftoggleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).toggle((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOfftoggleCommandParams); + onOffClusterInteractionInfoMap.put("toggle", onOfftoggleInteractionInfo); + commandMap.put("onOff", onOffClusterInteractionInfoMap); + Map onOffSwitchConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInteractionInfoMap); + Map operationalCredentialsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map operationalCredentialsaddNOCCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = + new CommandParameterInfo("NOCValue", byte[].class); + operationalCredentialsaddNOCCommandParams.put( + "NOCValue", operationalCredentialsaddNOCNOCValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = + new CommandParameterInfo("ICACValue", Optional.class); + operationalCredentialsaddNOCCommandParams.put( + "ICACValue", operationalCredentialsaddNOCICACValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = + new CommandParameterInfo("IPKValue", byte[].class); + operationalCredentialsaddNOCCommandParams.put( + "IPKValue", operationalCredentialsaddNOCIPKValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = + new CommandParameterInfo("caseAdminNode", Long.class); + operationalCredentialsaddNOCCommandParams.put( + "caseAdminNode", operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = + new CommandParameterInfo("adminVendorId", Integer.class); + operationalCredentialsaddNOCCommandParams.put( + "adminVendorId", operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); + + InteractionInfo operationalCredentialsaddNOCInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .addNOC( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (byte[]) commandArguments.get("NOCValue"), + (Optional) commandArguments.get("ICACValue"), + (byte[]) commandArguments.get("IPKValue"), + (Long) commandArguments.get("caseAdminNode"), + (Integer) commandArguments.get("adminVendorId")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsaddNOCCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "addNOC", operationalCredentialsaddNOCInteractionInfo); + Map operationalCredentialsaddTrustedRootCertificateCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = + new CommandParameterInfo("rootCertificate", byte[].class); + operationalCredentialsaddTrustedRootCertificateCommandParams.put( + "rootCertificate", + operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); + + InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .addTrustedRootCertificate( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("rootCertificate")); + }, + () -> new DelegatedDefaultClusterCallback(), + operationalCredentialsaddTrustedRootCertificateCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "addTrustedRootCertificate", + operationalCredentialsaddTrustedRootCertificateInteractionInfo); + Map operationalCredentialsattestationRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = + new CommandParameterInfo("attestationNonce", byte[].class); + operationalCredentialsattestationRequestCommandParams.put( + "attestationNonce", + operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); + + InteractionInfo operationalCredentialsattestationRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .attestationRequest( + (ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) + callback, + (byte[]) commandArguments.get("attestationNonce")); + }, + () -> new DelegatedAttestationResponseCallback(), + operationalCredentialsattestationRequestCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "attestationRequest", operationalCredentialsattestationRequestInteractionInfo); + Map operationalCredentialscertificateChainRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = + new CommandParameterInfo("certificateType", Integer.class); + operationalCredentialscertificateChainRequestCommandParams.put( + "certificateType", + operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); + + InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .certificateChainRequest( + (ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) + callback, + (Integer) commandArguments.get("certificateType")); + }, + () -> new DelegatedCertificateChainResponseCallback(), + operationalCredentialscertificateChainRequestCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "certificateChainRequest", operationalCredentialscertificateChainRequestInteractionInfo); + Map operationalCredentialsopCSRRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = + new CommandParameterInfo("CSRNonce", byte[].class); + operationalCredentialsopCSRRequestCommandParams.put( + "CSRNonce", operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); + + InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .opCSRRequest( + (ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback, + (byte[]) commandArguments.get("CSRNonce")); + }, + () -> new DelegatedOpCSRResponseCallback(), + operationalCredentialsopCSRRequestCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "opCSRRequest", operationalCredentialsopCSRRequestInteractionInfo); + Map operationalCredentialsremoveFabricCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = + new CommandParameterInfo("fabricIndex", Integer.class); + operationalCredentialsremoveFabricCommandParams.put( + "fabricIndex", operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); + + InteractionInfo operationalCredentialsremoveFabricInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .removeFabric( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (Integer) commandArguments.get("fabricIndex")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsremoveFabricCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "removeFabric", operationalCredentialsremoveFabricInteractionInfo); + Map + operationalCredentialsremoveTrustedRootCertificateCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = + new CommandParameterInfo("trustedRootIdentifier", byte[].class); + operationalCredentialsremoveTrustedRootCertificateCommandParams.put( + "trustedRootIdentifier", + operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); + + InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .removeTrustedRootCertificate( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("trustedRootIdentifier")); + }, + () -> new DelegatedDefaultClusterCallback(), + operationalCredentialsremoveTrustedRootCertificateCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "removeTrustedRootCertificate", + operationalCredentialsremoveTrustedRootCertificateInteractionInfo); + Map operationalCredentialsupdateFabricLabelCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = + new CommandParameterInfo("label", String.class); + operationalCredentialsupdateFabricLabelCommandParams.put( + "label", operationalCredentialsupdateFabricLabellabelCommandParameterInfo); + + InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .updateFabricLabel( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (String) commandArguments.get("label")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsupdateFabricLabelCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "updateFabricLabel", operationalCredentialsupdateFabricLabelInteractionInfo); + Map operationalCredentialsupdateNOCCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = + new CommandParameterInfo("NOCValue", byte[].class); + operationalCredentialsupdateNOCCommandParams.put( + "NOCValue", operationalCredentialsupdateNOCNOCValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = + new CommandParameterInfo("ICACValue", Optional.class); + operationalCredentialsupdateNOCCommandParams.put( + "ICACValue", operationalCredentialsupdateNOCICACValueCommandParameterInfo); + + InteractionInfo operationalCredentialsupdateNOCInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .updateNOC( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (byte[]) commandArguments.get("NOCValue"), + (Optional) commandArguments.get("ICACValue")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsupdateNOCCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "updateNOC", operationalCredentialsupdateNOCInteractionInfo); + commandMap.put("operationalCredentials", operationalCredentialsClusterInteractionInfoMap); + Map powerSourceClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("powerSource", powerSourceClusterInteractionInfoMap); + Map powerSourceConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInteractionInfoMap); + Map pressureMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("pressureMeasurement", pressureMeasurementClusterInteractionInfoMap); + Map pumpConfigurationAndControlClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put( + "pumpConfigurationAndControl", pumpConfigurationAndControlClusterInteractionInfoMap); + Map relativeHumidityMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put( + "relativeHumidityMeasurement", relativeHumidityMeasurementClusterInteractionInfoMap); + Map scenesClusterInteractionInfoMap = new LinkedHashMap<>(); + Map scenesaddSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesaddSceneCommandParams.put("groupId", scenesaddScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesaddSceneCommandParams.put("sceneId", scenesaddScenesceneIdCommandParameterInfo); + + CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + scenesaddSceneCommandParams.put( + "transitionTime", scenesaddScenetransitionTimeCommandParameterInfo); + + CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = + new CommandParameterInfo("sceneName", String.class); + scenesaddSceneCommandParams.put("sceneName", scenesaddScenesceneNameCommandParameterInfo); + + InteractionInfo scenesaddSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .addScene( + (ChipClusters.ScenesCluster.AddSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId"), + (Integer) commandArguments.get("transitionTime"), + (String) commandArguments.get("sceneName"), + (ArrayList) + commandArguments.get("extensionFieldSets")); + }, + () -> new DelegatedAddSceneResponseCallback(), + scenesaddSceneCommandParams); + scenesClusterInteractionInfoMap.put("addScene", scenesaddSceneInteractionInfo); + Map scenesgetSceneMembershipCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesgetSceneMembershipCommandParams.put( + "groupId", scenesgetSceneMembershipgroupIdCommandParameterInfo); + + InteractionInfo scenesgetSceneMembershipInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .getSceneMembership( + (ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedGetSceneMembershipResponseCallback(), + scenesgetSceneMembershipCommandParams); + scenesClusterInteractionInfoMap.put( + "getSceneMembership", scenesgetSceneMembershipInteractionInfo); + Map scenesrecallSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesrecallSceneCommandParams.put("groupId", scenesrecallScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesrecallSceneCommandParams.put("sceneId", scenesrecallScenesceneIdCommandParameterInfo); + + CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + scenesrecallSceneCommandParams.put( + "transitionTime", scenesrecallScenetransitionTimeCommandParameterInfo); + + InteractionInfo scenesrecallSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .recallScene( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + scenesrecallSceneCommandParams); + scenesClusterInteractionInfoMap.put("recallScene", scenesrecallSceneInteractionInfo); + Map scenesremoveAllScenesCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesremoveAllScenesCommandParams.put( + "groupId", scenesremoveAllScenesgroupIdCommandParameterInfo); + + InteractionInfo scenesremoveAllScenesInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .removeAllScenes( + (ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedRemoveAllScenesResponseCallback(), + scenesremoveAllScenesCommandParams); + scenesClusterInteractionInfoMap.put("removeAllScenes", scenesremoveAllScenesInteractionInfo); + Map scenesremoveSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesremoveSceneCommandParams.put("groupId", scenesremoveScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesremoveSceneCommandParams.put("sceneId", scenesremoveScenesceneIdCommandParameterInfo); + + InteractionInfo scenesremoveSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .removeScene( + (ChipClusters.ScenesCluster.RemoveSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId")); + }, + () -> new DelegatedRemoveSceneResponseCallback(), + scenesremoveSceneCommandParams); + scenesClusterInteractionInfoMap.put("removeScene", scenesremoveSceneInteractionInfo); + Map scenesstoreSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesstoreSceneCommandParams.put("groupId", scenesstoreScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesstoreSceneCommandParams.put("sceneId", scenesstoreScenesceneIdCommandParameterInfo); + + InteractionInfo scenesstoreSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .storeScene( + (ChipClusters.ScenesCluster.StoreSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId")); + }, + () -> new DelegatedStoreSceneResponseCallback(), + scenesstoreSceneCommandParams); + scenesClusterInteractionInfoMap.put("storeScene", scenesstoreSceneInteractionInfo); + Map scenesviewSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesviewSceneCommandParams.put("groupId", scenesviewScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesviewSceneCommandParams.put("sceneId", scenesviewScenesceneIdCommandParameterInfo); + + InteractionInfo scenesviewSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .viewScene( + (ChipClusters.ScenesCluster.ViewSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId")); + }, + () -> new DelegatedViewSceneResponseCallback(), + scenesviewSceneCommandParams); + scenesClusterInteractionInfoMap.put("viewScene", scenesviewSceneInteractionInfo); + commandMap.put("scenes", scenesClusterInteractionInfoMap); + Map softwareDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map softwareDiagnosticsresetWatermarksCommandParams = + new LinkedHashMap(); + InteractionInfo softwareDiagnosticsresetWatermarksInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .resetWatermarks((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + softwareDiagnosticsresetWatermarksCommandParams); + softwareDiagnosticsClusterInteractionInfoMap.put( + "resetWatermarks", softwareDiagnosticsresetWatermarksInteractionInfo); + commandMap.put("softwareDiagnostics", softwareDiagnosticsClusterInteractionInfoMap); + Map switchClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("switch", switchClusterInteractionInfoMap); + Map targetNavigatorClusterInteractionInfoMap = new LinkedHashMap<>(); + Map targetNavigatornavigateTargetRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = + new CommandParameterInfo("target", Integer.class); + targetNavigatornavigateTargetRequestCommandParams.put( + "target", targetNavigatornavigateTargetRequesttargetCommandParameterInfo); + + CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = + new CommandParameterInfo("data", String.class); + targetNavigatornavigateTargetRequestCommandParams.put( + "data", targetNavigatornavigateTargetRequestdataCommandParameterInfo); + + InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .navigateTargetRequest( + (ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback) callback, + (Integer) commandArguments.get("target"), + (String) commandArguments.get("data")); + }, + () -> new DelegatedNavigateTargetResponseCallback(), + targetNavigatornavigateTargetRequestCommandParams); + targetNavigatorClusterInteractionInfoMap.put( + "navigateTargetRequest", targetNavigatornavigateTargetRequestInteractionInfo); + commandMap.put("targetNavigator", targetNavigatorClusterInteractionInfoMap); + Map temperatureMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); + Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); + Map testClustersimpleStructEchoRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustersimpleStructEchoRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .simpleStructEchoRequest( + (ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback, + (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1")); + }, + () -> new DelegatedSimpleStructResponseCallback(), + testClustersimpleStructEchoRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "simpleStructEchoRequest", testClustersimpleStructEchoRequestInteractionInfo); + Map testClustertestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).test((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestCommandParams); + testClusterClusterInteractionInfoMap.put("test", testClustertestInteractionInfo); + Map testClustertestAddArgumentsCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Integer.class); + testClustertestAddArgumentsCommandParams.put( + "arg1", testClustertestAddArgumentsarg1CommandParameterInfo); + + CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = + new CommandParameterInfo("arg2", Integer.class); + testClustertestAddArgumentsCommandParams.put( + "arg2", testClustertestAddArgumentsarg2CommandParameterInfo); + + InteractionInfo testClustertestAddArgumentsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testAddArguments( + (ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback) callback, + (Integer) commandArguments.get("arg1"), + (Integer) commandArguments.get("arg2")); + }, + () -> new DelegatedTestAddArgumentsResponseCallback(), + testClustertestAddArgumentsCommandParams); + testClusterClusterInteractionInfoMap.put( + "testAddArguments", testClustertestAddArgumentsInteractionInfo); + Map testClustertestEmitTestEventRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Integer.class); + testClustertestEmitTestEventRequestCommandParams.put( + "arg1", testClustertestEmitTestEventRequestarg1CommandParameterInfo); + + CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = + new CommandParameterInfo("arg2", Integer.class); + testClustertestEmitTestEventRequestCommandParams.put( + "arg2", testClustertestEmitTestEventRequestarg2CommandParameterInfo); + + CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = + new CommandParameterInfo("arg3", Boolean.class); + testClustertestEmitTestEventRequestCommandParams.put( + "arg3", testClustertestEmitTestEventRequestarg3CommandParameterInfo); + + InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testEmitTestEventRequest( + (ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback) callback, + (Integer) commandArguments.get("arg1"), + (Integer) commandArguments.get("arg2"), + (Boolean) commandArguments.get("arg3")); + }, + () -> new DelegatedTestEmitTestEventResponseCallback(), + testClustertestEmitTestEventRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testEmitTestEventRequest", testClustertestEmitTestEventRequestInteractionInfo); + Map testClustertestEnumsRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Integer.class); + testClustertestEnumsRequestCommandParams.put( + "arg1", testClustertestEnumsRequestarg1CommandParameterInfo); + + CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = + new CommandParameterInfo("arg2", Integer.class); + testClustertestEnumsRequestCommandParams.put( + "arg2", testClustertestEnumsRequestarg2CommandParameterInfo); + + InteractionInfo testClustertestEnumsRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testEnumsRequest( + (ChipClusters.TestClusterCluster.TestEnumsResponseCallback) callback, + (Integer) commandArguments.get("arg1"), + (Integer) commandArguments.get("arg2")); + }, + () -> new DelegatedTestEnumsResponseCallback(), + testClustertestEnumsRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testEnumsRequest", testClustertestEnumsRequestInteractionInfo); + Map testClustertestListInt8UArgumentRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", ArrayList.class); + testClustertestListInt8UArgumentRequestCommandParams.put( + "arg1", testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListInt8UArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ArrayList) commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListInt8UArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestInteractionInfo); + Map testClustertestListInt8UReverseRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", ArrayList.class); + testClustertestListInt8UReverseRequestCommandParams.put( + "arg1", testClustertestListInt8UReverseRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListInt8UReverseRequest( + (ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) + callback, + (ArrayList) commandArguments.get("arg1")); + }, + () -> new DelegatedTestListInt8UReverseResponseCallback(), + testClustertestListInt8UReverseRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListInt8UReverseRequest", testClustertestListInt8UReverseRequestInteractionInfo); + Map + testClustertestListNestedStructListArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestListNestedStructListArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListNestedStructListArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ArrayList) + commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListNestedStructListArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListNestedStructListArgumentRequest", + testClustertestListNestedStructListArgumentRequestInteractionInfo); + Map testClustertestListStructArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListStructArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ArrayList) + commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListStructArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListStructArgumentRequest", testClustertestListStructArgumentRequestInteractionInfo); + Map testClustertestNestedStructArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestNestedStructArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNestedStructArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ChipStructs.TestClusterClusterNestedStruct) commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestNestedStructArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNestedStructArgumentRequest", + testClustertestNestedStructArgumentRequestInteractionInfo); + Map testClustertestNestedStructListArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestNestedStructListArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNestedStructListArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ChipStructs.TestClusterClusterNestedStructList) + commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestNestedStructListArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNestedStructListArgumentRequest", + testClustertestNestedStructListArgumentRequestInteractionInfo); + Map testClustertestNotHandledCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestNotHandledInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNotHandled((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestNotHandledCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNotHandled", testClustertestNotHandledInteractionInfo); + Map testClustertestNullableOptionalRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Optional.class); + testClustertestNullableOptionalRequestCommandParams.put( + "arg1", testClustertestNullableOptionalRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNullableOptionalRequest( + (ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) + callback, + (Optional) commandArguments.get("arg1")); + }, + () -> new DelegatedTestNullableOptionalResponseCallback(), + testClustertestNullableOptionalRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNullableOptionalRequest", testClustertestNullableOptionalRequestInteractionInfo); + Map testClustertestSimpleOptionalArgumentRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Optional.class); + testClustertestSimpleOptionalArgumentRequestCommandParams.put( + "arg1", testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testSimpleOptionalArgumentRequest( + (DefaultClusterCallback) callback, + (Optional) commandArguments.get("arg1")); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestSimpleOptionalArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testSimpleOptionalArgumentRequest", + testClustertestSimpleOptionalArgumentRequestInteractionInfo); + Map testClustertestSpecificCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestSpecificInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testSpecific( + (ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback); + }, + () -> new DelegatedTestSpecificResponseCallback(), + testClustertestSpecificCommandParams); + testClusterClusterInteractionInfoMap.put( + "testSpecific", testClustertestSpecificInteractionInfo); + Map testClustertestStructArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestStructArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testStructArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestStructArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testStructArgumentRequest", testClustertestStructArgumentRequestInteractionInfo); + Map testClustertestUnknownCommandCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestUnknownCommandInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testUnknownCommand((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestUnknownCommandCommandParams); + testClusterClusterInteractionInfoMap.put( + "testUnknownCommand", testClustertestUnknownCommandInteractionInfo); + Map testClustertimedInvokeRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertimedInvokeRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .timedInvokeRequest((DefaultClusterCallback) callback, 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertimedInvokeRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "timedInvokeRequest", testClustertimedInvokeRequestInteractionInfo); + commandMap.put("testCluster", testClusterClusterInteractionInfoMap); + Map thermostatClusterInteractionInfoMap = new LinkedHashMap<>(); + Map thermostatclearWeeklyScheduleCommandParams = + new LinkedHashMap(); + InteractionInfo thermostatclearWeeklyScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .clearWeeklySchedule((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatclearWeeklyScheduleCommandParams); + thermostatClusterInteractionInfoMap.put( + "clearWeeklySchedule", thermostatclearWeeklyScheduleInteractionInfo); + Map thermostatgetRelayStatusLogCommandParams = + new LinkedHashMap(); + InteractionInfo thermostatgetRelayStatusLogInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .getRelayStatusLog( + (ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback); + }, + () -> new DelegatedGetRelayStatusLogResponseCallback(), + thermostatgetRelayStatusLogCommandParams); + thermostatClusterInteractionInfoMap.put( + "getRelayStatusLog", thermostatgetRelayStatusLogInteractionInfo); + Map thermostatgetWeeklyScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = + new CommandParameterInfo("daysToReturn", Integer.class); + thermostatgetWeeklyScheduleCommandParams.put( + "daysToReturn", thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); + + CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = + new CommandParameterInfo("modeToReturn", Integer.class); + thermostatgetWeeklyScheduleCommandParams.put( + "modeToReturn", thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); + + InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .getWeeklySchedule( + (ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback) callback, + (Integer) commandArguments.get("daysToReturn"), + (Integer) commandArguments.get("modeToReturn")); + }, + () -> new DelegatedGetWeeklyScheduleResponseCallback(), + thermostatgetWeeklyScheduleCommandParams); + thermostatClusterInteractionInfoMap.put( + "getWeeklySchedule", thermostatgetWeeklyScheduleInteractionInfo); + Map thermostatsetWeeklyScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo + thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = + new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put( + "numberOfTransitionsForSequence", + thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = + new CommandParameterInfo("dayOfWeekForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put( + "dayOfWeekForSequence", + thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = + new CommandParameterInfo("modeForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put( + "modeForSequence", thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = + new CommandParameterInfo("payload", ArrayList.class); + thermostatsetWeeklyScheduleCommandParams.put( + "payload", thermostatsetWeeklySchedulepayloadCommandParameterInfo); + + InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .setWeeklySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("numberOfTransitionsForSequence"), + (Integer) commandArguments.get("dayOfWeekForSequence"), + (Integer) commandArguments.get("modeForSequence"), + (ArrayList) commandArguments.get("payload")); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatsetWeeklyScheduleCommandParams); + thermostatClusterInteractionInfoMap.put( + "setWeeklySchedule", thermostatsetWeeklyScheduleInteractionInfo); + Map thermostatsetpointRaiseLowerCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = + new CommandParameterInfo("mode", Integer.class); + thermostatsetpointRaiseLowerCommandParams.put( + "mode", thermostatsetpointRaiseLowermodeCommandParameterInfo); + + CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = + new CommandParameterInfo("amount", Integer.class); + thermostatsetpointRaiseLowerCommandParams.put( + "amount", thermostatsetpointRaiseLoweramountCommandParameterInfo); + + InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .setpointRaiseLower( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("mode"), + (Integer) commandArguments.get("amount")); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatsetpointRaiseLowerCommandParams); + thermostatClusterInteractionInfoMap.put( + "setpointRaiseLower", thermostatsetpointRaiseLowerInteractionInfo); + commandMap.put("thermostat", thermostatClusterInteractionInfoMap); + Map thermostatUserInterfaceConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put( + "thermostatUserInterfaceConfiguration", + thermostatUserInterfaceConfigurationClusterInteractionInfoMap); + Map threadNetworkDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map threadNetworkDiagnosticsresetCountsCommandParams = + new LinkedHashMap(); + InteractionInfo threadNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + threadNetworkDiagnosticsresetCountsCommandParams); + threadNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", threadNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInteractionInfoMap); + Map timeFormatLocalizationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("timeFormatLocalization", timeFormatLocalizationClusterInteractionInfoMap); + Map unitLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("unitLocalization", unitLocalizationClusterInteractionInfoMap); + Map userLabelClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("userLabel", userLabelClusterInteractionInfoMap); + Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); + Map wiFiNetworkDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map wiFiNetworkDiagnosticsresetCountsCommandParams = + new LinkedHashMap(); + InteractionInfo wiFiNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + wiFiNetworkDiagnosticsresetCountsCommandParams); + wiFiNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", wiFiNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInteractionInfoMap); + Map windowCoveringClusterInteractionInfoMap = new LinkedHashMap<>(); + Map windowCoveringdownOrCloseCommandParams = + new LinkedHashMap(); + InteractionInfo windowCoveringdownOrCloseInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .downOrClose((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringdownOrCloseCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "downOrClose", windowCoveringdownOrCloseInteractionInfo); + Map windowCoveringgoToLiftPercentageCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = + new CommandParameterInfo("liftPercentageValue", Integer.class); + windowCoveringgoToLiftPercentageCommandParams.put( + "liftPercentageValue", + windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); + + CommandParameterInfo + windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = + new CommandParameterInfo("liftPercent100thsValue", Integer.class); + windowCoveringgoToLiftPercentageCommandParams.put( + "liftPercent100thsValue", + windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToLiftPercentage( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("liftPercentageValue"), + (Integer) commandArguments.get("liftPercent100thsValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToLiftPercentageCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToLiftPercentage", windowCoveringgoToLiftPercentageInteractionInfo); + Map windowCoveringgoToLiftValueCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = + new CommandParameterInfo("liftValue", Integer.class); + windowCoveringgoToLiftValueCommandParams.put( + "liftValue", windowCoveringgoToLiftValueliftValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToLiftValueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToLiftValue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("liftValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToLiftValueCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToLiftValue", windowCoveringgoToLiftValueInteractionInfo); + Map windowCoveringgoToTiltPercentageCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = + new CommandParameterInfo("tiltPercentageValue", Integer.class); + windowCoveringgoToTiltPercentageCommandParams.put( + "tiltPercentageValue", + windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); + + CommandParameterInfo + windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = + new CommandParameterInfo("tiltPercent100thsValue", Integer.class); + windowCoveringgoToTiltPercentageCommandParams.put( + "tiltPercent100thsValue", + windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToTiltPercentage( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("tiltPercentageValue"), + (Integer) commandArguments.get("tiltPercent100thsValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToTiltPercentageCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToTiltPercentage", windowCoveringgoToTiltPercentageInteractionInfo); + Map windowCoveringgoToTiltValueCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = + new CommandParameterInfo("tiltValue", Integer.class); + windowCoveringgoToTiltValueCommandParams.put( + "tiltValue", windowCoveringgoToTiltValuetiltValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToTiltValueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToTiltValue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("tiltValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToTiltValueCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToTiltValue", windowCoveringgoToTiltValueInteractionInfo); + Map windowCoveringstopMotionCommandParams = + new LinkedHashMap(); + InteractionInfo windowCoveringstopMotionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .stopMotion((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringstopMotionCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "stopMotion", windowCoveringstopMotionInteractionInfo); + Map windowCoveringupOrOpenCommandParams = + new LinkedHashMap(); + InteractionInfo windowCoveringupOrOpenInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .upOrOpen((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringupOrOpenCommandParams); + windowCoveringClusterInteractionInfoMap.put("upOrOpen", windowCoveringupOrOpenInteractionInfo); + commandMap.put("windowCovering", windowCoveringClusterInteractionInfoMap); + return commandMap; + } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java index e433d2ce7db37d..2dc210109c6a96 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java @@ -29,8044 +29,8466 @@ public class ClusterReadMapping { public Map> getReadAttributeMap() { Map> readAttributeMap = new HashMap<>(); - Map readAccessControlInteractionInfo = new LinkedHashMap<>(); - Map readAccessControlAclCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlAclAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readAclAttribute( - ( ChipClusters.AccessControlCluster.AclAttributeCallback - ) callback - ); - }, + Map readAccessControlInteractionInfo = 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 - ); - readAccessControlInteractionInfo.put("readAclAttribute", readAccessControlAclAttributeInteractionInfo); - Map readAccessControlExtensionCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlExtensionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readExtensionAttribute( - ( ChipClusters.AccessControlCluster.ExtensionAttributeCallback - ) callback - ); - }, + readAccessControlAclCommandParams); + readAccessControlInteractionInfo.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 - ); - readAccessControlInteractionInfo.put("readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); - Map readAccessControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AccessControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterAttributeListAttributeCallback(), - readAccessControlAttributeListCommandParams - ); - readAccessControlInteractionInfo.put("readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); - Map readAccessControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlClusterRevisionCommandParams - ); - readAccessControlInteractionInfo.put("readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("accessControl", readAccessControlInteractionInfo); - Map readAccountLoginInteractionInfo = new LinkedHashMap<>(); - Map readAccountLoginAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AccountLoginCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), - readAccountLoginAttributeListCommandParams - ); - readAccountLoginInteractionInfo.put("readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); - Map readAccountLoginClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccountLoginClusterRevisionCommandParams - ); - readAccountLoginInteractionInfo.put("readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("accountLogin", readAccountLoginInteractionInfo); - Map readAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readAdministratorCommissioningWindowStatusCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readWindowStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningWindowStatusCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readWindowStatusAttribute", readAdministratorCommissioningWindowStatusAttributeInteractionInfo); - Map readAdministratorCommissioningAdminFabricIndexCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminFabricIndexAttribute( - ( ChipClusters.AdministratorCommissioningCluster.AdminFabricIndexAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningAdminFabricIndexCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readAdminFabricIndexAttribute", readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); - Map readAdministratorCommissioningAdminVendorIdCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminVendorIdAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningAdminVendorIdCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readAdminVendorIdAttribute", readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); - Map readAdministratorCommissioningAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AdministratorCommissioningCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), - readAdministratorCommissioningAttributeListCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readAttributeListAttribute", readAdministratorCommissioningAttributeListAttributeInteractionInfo); - Map readAdministratorCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningClusterRevisionCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readClusterRevisionAttribute", readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("administratorCommissioning", readAdministratorCommissioningInteractionInfo); - Map readApplicationBasicInteractionInfo = new LinkedHashMap<>(); - Map readApplicationBasicVendorNameCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readVendorNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readAccessControlExtensionCommandParams); + readAccessControlInteractionInfo.put( + "readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); + Map readAccessControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AccessControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAccessControlClusterAttributeListAttributeCallback(), + readAccessControlAttributeListCommandParams); + readAccessControlInteractionInfo.put( + "readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); + Map readAccessControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlClusterRevisionCommandParams); + readAccessControlInteractionInfo.put( + "readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("accessControl", readAccessControlInteractionInfo); + Map readAccountLoginInteractionInfo = new LinkedHashMap<>(); + Map readAccountLoginAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AccountLoginCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), + readAccountLoginAttributeListCommandParams); + readAccountLoginInteractionInfo.put( + "readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); + Map readAccountLoginClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccountLoginClusterRevisionCommandParams); + readAccountLoginInteractionInfo.put( + "readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("accountLogin", readAccountLoginInteractionInfo); + Map readAdministratorCommissioningInteractionInfo = + new LinkedHashMap<>(); + Map readAdministratorCommissioningWindowStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readWindowStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningWindowStatusCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readWindowStatusAttribute", + readAdministratorCommissioningWindowStatusAttributeInteractionInfo); + Map readAdministratorCommissioningAdminFabricIndexCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAdminFabricIndexAttribute( + (ChipClusters.AdministratorCommissioningCluster + .AdminFabricIndexAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningAdminFabricIndexCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readAdminFabricIndexAttribute", + readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); + Map readAdministratorCommissioningAdminVendorIdCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAdminVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningAdminVendorIdCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readAdminVendorIdAttribute", + readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); + Map readAdministratorCommissioningAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AdministratorCommissioningCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), + readAdministratorCommissioningAttributeListCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readAttributeListAttribute", + readAdministratorCommissioningAttributeListAttributeInteractionInfo); + Map readAdministratorCommissioningClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningClusterRevisionCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readClusterRevisionAttribute", + readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "administratorCommissioning", readAdministratorCommissioningInteractionInfo); + Map readApplicationBasicInteractionInfo = new LinkedHashMap<>(); + Map readApplicationBasicVendorNameCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicVendorNameCommandParams - ); - readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.put("readVendorIdAttribute", readApplicationBasicVendorIdAttributeInteractionInfo); - Map readApplicationBasicApplicationNameCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readApplicationBasicVendorNameCommandParams); + readApplicationBasicInteractionInfo.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); + readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.put("readProductIdAttribute", readApplicationBasicProductIdAttributeInteractionInfo); - Map readApplicationBasicApplicationStatusCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicApplicationStatusCommandParams - ); - readApplicationBasicInteractionInfo.put("readApplicationStatusAttribute", readApplicationBasicApplicationStatusAttributeInteractionInfo); - Map readApplicationBasicApplicationVersionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationVersionAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readApplicationBasicApplicationNameCommandParams); + readApplicationBasicInteractionInfo.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); + readApplicationBasicInteractionInfo.put( + "readProductIdAttribute", readApplicationBasicProductIdAttributeInteractionInfo); + Map readApplicationBasicApplicationStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readApplicationStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicApplicationStatusCommandParams); + readApplicationBasicInteractionInfo.put( + "readApplicationStatusAttribute", + readApplicationBasicApplicationStatusAttributeInteractionInfo); + Map readApplicationBasicApplicationVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readApplicationVersionAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicApplicationVersionCommandParams - ); - readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.put("readAllowedVendorListAttribute", readApplicationBasicAllowedVendorListAttributeInteractionInfo); - Map readApplicationBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterAttributeListAttributeCallback(), - readApplicationBasicAttributeListCommandParams - ); - readApplicationBasicInteractionInfo.put("readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); - Map readApplicationBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicClusterRevisionCommandParams - ); - readApplicationBasicInteractionInfo.put("readClusterRevisionAttribute", readApplicationBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("applicationBasic", readApplicationBasicInteractionInfo); - Map readApplicationLauncherInteractionInfo = new LinkedHashMap<>(); - Map readApplicationLauncherApplicationLauncherListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherApplicationLauncherListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readApplicationLauncherListAttribute( - ( ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback(), - readApplicationLauncherApplicationLauncherListCommandParams - ); - readApplicationLauncherInteractionInfo.put("readApplicationLauncherListAttribute", readApplicationLauncherApplicationLauncherListAttributeInteractionInfo); - Map readApplicationLauncherAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), - readApplicationLauncherAttributeListCommandParams - ); - readApplicationLauncherInteractionInfo.put("readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); - Map readApplicationLauncherClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationLauncherClusterRevisionCommandParams - ); - readApplicationLauncherInteractionInfo.put("readClusterRevisionAttribute", readApplicationLauncherClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("applicationLauncher", readApplicationLauncherInteractionInfo); - Map readAudioOutputInteractionInfo = new LinkedHashMap<>(); - Map readAudioOutputAudioOutputListCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputAudioOutputListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readAudioOutputListAttribute( - ( ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAudioOutputListAttributeCallback(), - readAudioOutputAudioOutputListCommandParams - ); - readAudioOutputInteractionInfo.put("readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeInteractionInfo); - Map readAudioOutputCurrentAudioOutputCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputCurrentAudioOutputAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readCurrentAudioOutputAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputCurrentAudioOutputCommandParams - ); - readAudioOutputInteractionInfo.put("readCurrentAudioOutputAttribute", readAudioOutputCurrentAudioOutputAttributeInteractionInfo); - Map readAudioOutputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AudioOutputCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), - readAudioOutputAttributeListCommandParams - ); - readAudioOutputInteractionInfo.put("readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); - Map readAudioOutputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputClusterRevisionCommandParams - ); - readAudioOutputInteractionInfo.put("readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("audioOutput", readAudioOutputInteractionInfo); - Map readBarrierControlInteractionInfo = new LinkedHashMap<>(); - Map readBarrierControlBarrierMovingStateCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierMovingStateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierMovingStateCommandParams - ); - readBarrierControlInteractionInfo.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 - ); - readBarrierControlInteractionInfo.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 - ); - readBarrierControlInteractionInfo.put("readBarrierCapabilitiesAttribute", readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); - Map readBarrierControlBarrierPositionCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierPositionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierPositionCommandParams - ); - readBarrierControlInteractionInfo.put("readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); - Map readBarrierControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BarrierControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBarrierControlClusterAttributeListAttributeCallback(), - readBarrierControlAttributeListCommandParams - ); - readBarrierControlInteractionInfo.put("readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); - Map readBarrierControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlClusterRevisionCommandParams - ); - readBarrierControlInteractionInfo.put("readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("barrierControl", readBarrierControlInteractionInfo); - Map readBasicInteractionInfo = new LinkedHashMap<>(); - Map readBasicInteractionModelVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInteractionModelVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readInteractionModelVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInteractionModelVersionCommandParams - ); - readBasicInteractionInfo.put("readInteractionModelVersionAttribute", readBasicInteractionModelVersionAttributeInteractionInfo); - Map readBasicVendorNameCommandParams = new LinkedHashMap(); - InteractionInfo readBasicVendorNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readVendorNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readApplicationBasicApplicationVersionCommandParams); + readApplicationBasicInteractionInfo.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); + readApplicationBasicInteractionInfo.put( + "readAllowedVendorListAttribute", + readApplicationBasicAllowedVendorListAttributeInteractionInfo); + Map readApplicationBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationBasicClusterAttributeListAttributeCallback(), + readApplicationBasicAttributeListCommandParams); + readApplicationBasicInteractionInfo.put( + "readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); + Map readApplicationBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicClusterRevisionCommandParams); + readApplicationBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readApplicationBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationBasic", readApplicationBasicInteractionInfo); + Map readApplicationLauncherInteractionInfo = new LinkedHashMap<>(); + Map readApplicationLauncherApplicationLauncherListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherApplicationLauncherListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readApplicationLauncherListAttribute( + (ChipClusters.ApplicationLauncherCluster + .ApplicationLauncherListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback(), + readApplicationLauncherApplicationLauncherListCommandParams); + readApplicationLauncherInteractionInfo.put( + "readApplicationLauncherListAttribute", + readApplicationLauncherApplicationLauncherListAttributeInteractionInfo); + Map readApplicationLauncherAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), + readApplicationLauncherAttributeListCommandParams); + readApplicationLauncherInteractionInfo.put( + "readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); + Map readApplicationLauncherClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationLauncherClusterRevisionCommandParams); + readApplicationLauncherInteractionInfo.put( + "readClusterRevisionAttribute", + readApplicationLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationLauncher", readApplicationLauncherInteractionInfo); + Map readAudioOutputInteractionInfo = new LinkedHashMap<>(); + Map readAudioOutputAudioOutputListCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputAudioOutputListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readAudioOutputListAttribute( + (ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAudioOutputClusterAudioOutputListAttributeCallback(), + readAudioOutputAudioOutputListCommandParams); + readAudioOutputInteractionInfo.put( + "readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeInteractionInfo); + Map readAudioOutputCurrentAudioOutputCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputCurrentAudioOutputAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readCurrentAudioOutputAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputCurrentAudioOutputCommandParams); + readAudioOutputInteractionInfo.put( + "readCurrentAudioOutputAttribute", + readAudioOutputCurrentAudioOutputAttributeInteractionInfo); + Map readAudioOutputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AudioOutputCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), + readAudioOutputAttributeListCommandParams); + readAudioOutputInteractionInfo.put( + "readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); + Map readAudioOutputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputClusterRevisionCommandParams); + readAudioOutputInteractionInfo.put( + "readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("audioOutput", readAudioOutputInteractionInfo); + Map readBarrierControlInteractionInfo = new LinkedHashMap<>(); + Map readBarrierControlBarrierMovingStateCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierMovingStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierMovingStateCommandParams); + readBarrierControlInteractionInfo.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); + readBarrierControlInteractionInfo.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); + readBarrierControlInteractionInfo.put( + "readBarrierCapabilitiesAttribute", + readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); + Map readBarrierControlBarrierPositionCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierPositionCommandParams); + readBarrierControlInteractionInfo.put( + "readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); + Map readBarrierControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BarrierControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBarrierControlClusterAttributeListAttributeCallback(), + readBarrierControlAttributeListCommandParams); + readBarrierControlInteractionInfo.put( + "readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); + Map readBarrierControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlClusterRevisionCommandParams); + readBarrierControlInteractionInfo.put( + "readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("barrierControl", readBarrierControlInteractionInfo); + Map readBasicInteractionInfo = new LinkedHashMap<>(); + Map readBasicInteractionModelVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInteractionModelVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readInteractionModelVersionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInteractionModelVersionCommandParams); + readBasicInteractionInfo.put( + "readInteractionModelVersionAttribute", + readBasicInteractionModelVersionAttributeInteractionInfo); + Map readBasicVendorNameCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicVendorNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicVendorNameCommandParams - ); - readBasicInteractionInfo.put("readVendorNameAttribute", readBasicVendorNameAttributeInteractionInfo); - Map readBasicVendorIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicVendorIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readVendorIDAttribute( - ( ChipClusters.BasicCluster.VendorIDAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicVendorIDCommandParams - ); - readBasicInteractionInfo.put("readVendorIDAttribute", readBasicVendorIDAttributeInteractionInfo); - Map readBasicProductNameCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicVendorNameCommandParams); + readBasicInteractionInfo.put( + "readVendorNameAttribute", readBasicVendorNameAttributeInteractionInfo); + Map readBasicVendorIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicVendorIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readVendorIDAttribute( + (ChipClusters.BasicCluster.VendorIDAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicVendorIDCommandParams); + readBasicInteractionInfo.put( + "readVendorIDAttribute", readBasicVendorIDAttributeInteractionInfo); + Map readBasicProductNameCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductNameCommandParams - ); - readBasicInteractionInfo.put("readProductNameAttribute", readBasicProductNameAttributeInteractionInfo); - Map readBasicProductIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductIDAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicProductIDCommandParams - ); - readBasicInteractionInfo.put("readProductIDAttribute", readBasicProductIDAttributeInteractionInfo); - Map readBasicNodeLabelCommandParams = new LinkedHashMap(); - InteractionInfo readBasicNodeLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readNodeLabelAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicProductNameCommandParams); + readBasicInteractionInfo.put( + "readProductNameAttribute", readBasicProductNameAttributeInteractionInfo); + Map readBasicProductIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductIDAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicProductIDCommandParams); + readBasicInteractionInfo.put( + "readProductIDAttribute", readBasicProductIDAttributeInteractionInfo); + Map readBasicNodeLabelCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicNodeLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readNodeLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicNodeLabelCommandParams - ); - readBasicInteractionInfo.put("readNodeLabelAttribute", readBasicNodeLabelAttributeInteractionInfo); - Map readBasicLocationCommandParams = new LinkedHashMap(); - InteractionInfo readBasicLocationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readLocationAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicNodeLabelCommandParams); + readBasicInteractionInfo.put( + "readNodeLabelAttribute", readBasicNodeLabelAttributeInteractionInfo); + Map readBasicLocationCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicLocationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readLocationAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicLocationCommandParams - ); - readBasicInteractionInfo.put("readLocationAttribute", readBasicLocationAttributeInteractionInfo); - Map readBasicHardwareVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicHardwareVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readHardwareVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicHardwareVersionCommandParams - ); - readBasicInteractionInfo.put("readHardwareVersionAttribute", readBasicHardwareVersionAttributeInteractionInfo); - Map readBasicHardwareVersionStringCommandParams = new LinkedHashMap(); - InteractionInfo readBasicHardwareVersionStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readHardwareVersionStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicLocationCommandParams); + readBasicInteractionInfo.put( + "readLocationAttribute", readBasicLocationAttributeInteractionInfo); + Map readBasicHardwareVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicHardwareVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readHardwareVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicHardwareVersionCommandParams); + readBasicInteractionInfo.put( + "readHardwareVersionAttribute", readBasicHardwareVersionAttributeInteractionInfo); + Map readBasicHardwareVersionStringCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicHardwareVersionStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readHardwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicHardwareVersionStringCommandParams - ); - readBasicInteractionInfo.put("readHardwareVersionStringAttribute", readBasicHardwareVersionStringAttributeInteractionInfo); - Map readBasicSoftwareVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicSoftwareVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readSoftwareVersionAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readBasicHardwareVersionStringCommandParams); + readBasicInteractionInfo.put( + "readHardwareVersionStringAttribute", + readBasicHardwareVersionStringAttributeInteractionInfo); + Map readBasicSoftwareVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicSoftwareVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readSoftwareVersionAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBasicSoftwareVersionCommandParams - ); - readBasicInteractionInfo.put("readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeInteractionInfo); - Map readBasicSoftwareVersionStringCommandParams = new LinkedHashMap(); - InteractionInfo readBasicSoftwareVersionStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readSoftwareVersionStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicSoftwareVersionCommandParams); + readBasicInteractionInfo.put( + "readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeInteractionInfo); + Map readBasicSoftwareVersionStringCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicSoftwareVersionStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readSoftwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicSoftwareVersionStringCommandParams - ); - readBasicInteractionInfo.put("readSoftwareVersionStringAttribute", readBasicSoftwareVersionStringAttributeInteractionInfo); - Map readBasicManufacturingDateCommandParams = new LinkedHashMap(); - InteractionInfo readBasicManufacturingDateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readManufacturingDateAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicSoftwareVersionStringCommandParams); + readBasicInteractionInfo.put( + "readSoftwareVersionStringAttribute", + readBasicSoftwareVersionStringAttributeInteractionInfo); + Map readBasicManufacturingDateCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicManufacturingDateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readManufacturingDateAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicManufacturingDateCommandParams - ); - readBasicInteractionInfo.put("readManufacturingDateAttribute", readBasicManufacturingDateAttributeInteractionInfo); - Map readBasicPartNumberCommandParams = new LinkedHashMap(); - InteractionInfo readBasicPartNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readPartNumberAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicManufacturingDateCommandParams); + readBasicInteractionInfo.put( + "readManufacturingDateAttribute", readBasicManufacturingDateAttributeInteractionInfo); + Map readBasicPartNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicPartNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readPartNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicPartNumberCommandParams - ); - readBasicInteractionInfo.put("readPartNumberAttribute", readBasicPartNumberAttributeInteractionInfo); - Map readBasicProductURLCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductURLAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductURLAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicPartNumberCommandParams); + readBasicInteractionInfo.put( + "readPartNumberAttribute", readBasicPartNumberAttributeInteractionInfo); + Map readBasicProductURLCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductURLAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductURLAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductURLCommandParams - ); - readBasicInteractionInfo.put("readProductURLAttribute", readBasicProductURLAttributeInteractionInfo); - Map readBasicProductLabelCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductLabelAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicProductURLCommandParams); + readBasicInteractionInfo.put( + "readProductURLAttribute", readBasicProductURLAttributeInteractionInfo); + Map readBasicProductLabelCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductLabelCommandParams - ); - readBasicInteractionInfo.put("readProductLabelAttribute", readBasicProductLabelAttributeInteractionInfo); - Map readBasicSerialNumberCommandParams = new LinkedHashMap(); - InteractionInfo readBasicSerialNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readSerialNumberAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicProductLabelCommandParams); + readBasicInteractionInfo.put( + "readProductLabelAttribute", readBasicProductLabelAttributeInteractionInfo); + Map readBasicSerialNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicSerialNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readSerialNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicSerialNumberCommandParams - ); - readBasicInteractionInfo.put("readSerialNumberAttribute", readBasicSerialNumberAttributeInteractionInfo); - Map readBasicLocalConfigDisabledCommandParams = new LinkedHashMap(); - InteractionInfo readBasicLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readLocalConfigDisabledAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBasicSerialNumberCommandParams); + readBasicInteractionInfo.put( + "readSerialNumberAttribute", readBasicSerialNumberAttributeInteractionInfo); + Map readBasicLocalConfigDisabledCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicLocalConfigDisabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readLocalConfigDisabledAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicLocalConfigDisabledCommandParams - ); - readBasicInteractionInfo.put("readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeInteractionInfo); - Map readBasicReachableCommandParams = new LinkedHashMap(); - InteractionInfo readBasicReachableAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readReachableAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBasicLocalConfigDisabledCommandParams); + readBasicInteractionInfo.put( + "readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeInteractionInfo); + Map readBasicReachableCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicReachableAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readReachableAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicReachableCommandParams - ); - readBasicInteractionInfo.put("readReachableAttribute", readBasicReachableAttributeInteractionInfo); - Map readBasicUniqueIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicUniqueIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readUniqueIDAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicReachableCommandParams); + readBasicInteractionInfo.put( + "readReachableAttribute", readBasicReachableAttributeInteractionInfo); + Map readBasicUniqueIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicUniqueIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readUniqueIDAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicUniqueIDCommandParams - ); - readBasicInteractionInfo.put("readUniqueIDAttribute", readBasicUniqueIDAttributeInteractionInfo); - Map readBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BasicCluster.AttributeListAttributeCallback - ) callback - ); - }, + readBasicUniqueIDCommandParams); + readBasicInteractionInfo.put( + "readUniqueIDAttribute", readBasicUniqueIDAttributeInteractionInfo); + Map readBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BasicCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBasicClusterAttributeListAttributeCallback(), - readBasicAttributeListCommandParams - ); - readBasicInteractionInfo.put("readAttributeListAttribute", readBasicAttributeListAttributeInteractionInfo); - Map readBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicClusterRevisionCommandParams - ); - readBasicInteractionInfo.put("readClusterRevisionAttribute", readBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("basic", readBasicInteractionInfo); - Map readBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map readBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readOutOfServiceAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBasicAttributeListCommandParams); + readBasicInteractionInfo.put( + "readAttributeListAttribute", readBasicAttributeListAttributeInteractionInfo); + Map readBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicClusterRevisionCommandParams); + readBasicInteractionInfo.put( + "readClusterRevisionAttribute", readBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("basic", readBasicInteractionInfo); + Map readBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); + Map readBinaryInputBasicOutOfServiceCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readOutOfServiceAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicOutOfServiceCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); - Map readBinaryInputBasicPresentValueCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readPresentValueAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBinaryInputBasicOutOfServiceCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); + Map readBinaryInputBasicPresentValueCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readPresentValueAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicPresentValueCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); - Map readBinaryInputBasicStatusFlagsCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readStatusFlagsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicStatusFlagsCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); - Map readBinaryInputBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), - readBinaryInputBasicAttributeListCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); - Map readBinaryInputBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicClusterRevisionCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readClusterRevisionAttribute", readBinaryInputBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("binaryInputBasic", readBinaryInputBasicInteractionInfo); - Map readBindingInteractionInfo = new LinkedHashMap<>(); - Map readBindingAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBindingAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BindingCluster.AttributeListAttributeCallback - ) callback - ); - }, + readBinaryInputBasicPresentValueCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); + Map readBinaryInputBasicStatusFlagsCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readStatusFlagsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicStatusFlagsCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); + Map readBinaryInputBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), + readBinaryInputBasicAttributeListCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); + Map readBinaryInputBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicClusterRevisionCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readBinaryInputBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binaryInputBasic", readBinaryInputBasicInteractionInfo); + Map readBindingInteractionInfo = new LinkedHashMap<>(); + Map readBindingAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BindingCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBindingClusterAttributeListAttributeCallback(), - readBindingAttributeListCommandParams - ); - readBindingInteractionInfo.put("readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); - Map readBindingClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBindingClusterRevisionCommandParams - ); - readBindingInteractionInfo.put("readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("binding", readBindingInteractionInfo); - Map readBooleanStateInteractionInfo = new LinkedHashMap<>(); - Map readBooleanStateStateValueCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readStateValueAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBindingAttributeListCommandParams); + readBindingInteractionInfo.put( + "readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); + Map readBindingClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBindingClusterRevisionCommandParams); + readBindingInteractionInfo.put( + "readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binding", readBindingInteractionInfo); + Map readBooleanStateInteractionInfo = new LinkedHashMap<>(); + Map readBooleanStateStateValueCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readStateValueAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBooleanStateStateValueCommandParams - ); - readBooleanStateInteractionInfo.put("readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); - Map readBooleanStateAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BooleanStateCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), - readBooleanStateAttributeListCommandParams - ); - readBooleanStateInteractionInfo.put("readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); - Map readBooleanStateClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBooleanStateClusterRevisionCommandParams - ); - readBooleanStateInteractionInfo.put("readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("booleanState", readBooleanStateInteractionInfo); - Map readBridgedActionsInteractionInfo = new LinkedHashMap<>(); - Map readBridgedActionsActionListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsActionListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readActionListAttribute( - ( ChipClusters.BridgedActionsCluster.ActionListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterActionListAttributeCallback(), - readBridgedActionsActionListCommandParams - ); - readBridgedActionsInteractionInfo.put("readActionListAttribute", readBridgedActionsActionListAttributeInteractionInfo); - Map readBridgedActionsEndpointListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsEndpointListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readEndpointListAttribute( - ( ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterEndpointListAttributeCallback(), - readBridgedActionsEndpointListCommandParams - ); - readBridgedActionsInteractionInfo.put("readEndpointListAttribute", readBridgedActionsEndpointListAttributeInteractionInfo); - Map readBridgedActionsSetupUrlCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsSetupUrlAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readSetupUrlAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBooleanStateStateValueCommandParams); + readBooleanStateInteractionInfo.put( + "readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); + Map readBooleanStateAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BooleanStateCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), + readBooleanStateAttributeListCommandParams); + readBooleanStateInteractionInfo.put( + "readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); + Map readBooleanStateClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanStateClusterRevisionCommandParams); + readBooleanStateInteractionInfo.put( + "readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("booleanState", readBooleanStateInteractionInfo); + Map readBridgedActionsInteractionInfo = new LinkedHashMap<>(); + Map readBridgedActionsActionListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsActionListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readActionListAttribute( + (ChipClusters.BridgedActionsCluster.ActionListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedBridgedActionsClusterActionListAttributeCallback(), + readBridgedActionsActionListCommandParams); + readBridgedActionsInteractionInfo.put( + "readActionListAttribute", readBridgedActionsActionListAttributeInteractionInfo); + Map readBridgedActionsEndpointListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsEndpointListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readEndpointListAttribute( + (ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedActionsClusterEndpointListAttributeCallback(), + readBridgedActionsEndpointListCommandParams); + readBridgedActionsInteractionInfo.put( + "readEndpointListAttribute", readBridgedActionsEndpointListAttributeInteractionInfo); + Map readBridgedActionsSetupUrlCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsSetupUrlAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readSetupUrlAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedActionsSetupUrlCommandParams - ); - readBridgedActionsInteractionInfo.put("readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeInteractionInfo); - Map readBridgedActionsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BridgedActionsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterAttributeListAttributeCallback(), - readBridgedActionsAttributeListCommandParams - ); - readBridgedActionsInteractionInfo.put("readAttributeListAttribute", readBridgedActionsAttributeListAttributeInteractionInfo); - Map readBridgedActionsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedActionsClusterRevisionCommandParams - ); - readBridgedActionsInteractionInfo.put("readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("bridgedActions", readBridgedActionsInteractionInfo); - Map readBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); - Map readBridgedDeviceBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BridgedDeviceBasicCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback(), - readBridgedDeviceBasicAttributeListCommandParams - ); - readBridgedDeviceBasicInteractionInfo.put("readAttributeListAttribute", readBridgedDeviceBasicAttributeListAttributeInteractionInfo); - Map readBridgedDeviceBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedDeviceBasicClusterRevisionCommandParams - ); - readBridgedDeviceBasicInteractionInfo.put("readClusterRevisionAttribute", readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("bridgedDeviceBasic", readBridgedDeviceBasicInteractionInfo); - Map readChannelInteractionInfo = new LinkedHashMap<>(); - Map readChannelChannelListCommandParams = new LinkedHashMap(); - InteractionInfo readChannelChannelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readChannelListAttribute( - ( ChipClusters.ChannelCluster.ChannelListAttributeCallback - ) callback - ); - }, + readBridgedActionsSetupUrlCommandParams); + readBridgedActionsInteractionInfo.put( + "readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeInteractionInfo); + Map readBridgedActionsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BridgedActionsCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedActionsClusterAttributeListAttributeCallback(), + readBridgedActionsAttributeListCommandParams); + readBridgedActionsInteractionInfo.put( + "readAttributeListAttribute", readBridgedActionsAttributeListAttributeInteractionInfo); + Map readBridgedActionsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedActionsClusterRevisionCommandParams); + readBridgedActionsInteractionInfo.put( + "readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedActions", readBridgedActionsInteractionInfo); + Map readBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); + Map readBridgedDeviceBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BridgedDeviceBasicCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback(), + readBridgedDeviceBasicAttributeListCommandParams); + readBridgedDeviceBasicInteractionInfo.put( + "readAttributeListAttribute", readBridgedDeviceBasicAttributeListAttributeInteractionInfo); + Map readBridgedDeviceBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedDeviceBasicClusterRevisionCommandParams); + readBridgedDeviceBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedDeviceBasic", readBridgedDeviceBasicInteractionInfo); + Map readChannelInteractionInfo = 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 - ); - readChannelInteractionInfo.put("readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); - Map readChannelAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readChannelAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ChannelCluster.AttributeListAttributeCallback - ) callback - ); - }, + readChannelChannelListCommandParams); + readChannelInteractionInfo.put( + "readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); + Map readChannelAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ChannelCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedChannelClusterAttributeListAttributeCallback(), - readChannelAttributeListCommandParams - ); - readChannelInteractionInfo.put("readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); - Map readChannelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readChannelClusterRevisionCommandParams - ); - readChannelInteractionInfo.put("readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("channel", readChannelInteractionInfo); - Map readColorControlInteractionInfo = new LinkedHashMap<>(); - Map readColorControlCurrentHueCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCurrentHueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentHueCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readDriftCompensationAttribute", readColorControlDriftCompensationAttributeInteractionInfo); - Map readColorControlCompensationTextCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCompensationTextAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCompensationTextAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readChannelAttributeListCommandParams); + readChannelInteractionInfo.put( + "readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); + Map readChannelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChannelClusterRevisionCommandParams); + readChannelInteractionInfo.put( + "readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("channel", readChannelInteractionInfo); + Map readColorControlInteractionInfo = new LinkedHashMap<>(); + Map readColorControlCurrentHueCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCurrentHueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentHueCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); - Map readColorControlColorTemperatureCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTemperatureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTemperatureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTemperatureCommandParams - ); - readColorControlInteractionInfo.put("readColorTemperatureAttribute", readColorControlColorTemperatureAttributeInteractionInfo); - Map readColorControlColorModeCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorModeCommandParams - ); - readColorControlInteractionInfo.put("readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); - Map readColorControlColorControlOptionsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorControlOptionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorControlOptionsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorControlOptionsCommandParams - ); - readColorControlInteractionInfo.put("readColorControlOptionsAttribute", readColorControlColorControlOptionsAttributeInteractionInfo); - Map readColorControlNumberOfPrimariesCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readNumberOfPrimariesAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlNumberOfPrimariesCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); - Map readColorControlPrimary1IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary1IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary1IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); - Map readColorControlPrimary2IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary2IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary2IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); - Map readColorControlPrimary3IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary3IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary3IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); - Map readColorControlPrimary4IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary4IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary4IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); - Map readColorControlPrimary5IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary5IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary5IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); - Map readColorControlPrimary6IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary6IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary6IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); - Map readColorControlColorPointRIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointRIntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointRIntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); - Map readColorControlColorPointGIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointGIntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointGIntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); - Map readColorControlColorPointBIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointBIntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointBIntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorCapabilitiesAttribute", readColorControlColorCapabilitiesAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMinCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMinAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMinCommandParams - ); - readColorControlInteractionInfo.put("readColorTempPhysicalMinAttribute", readColorControlColorTempPhysicalMinAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMaxCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMaxAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMaxCommandParams - ); - readColorControlInteractionInfo.put("readColorTempPhysicalMaxAttribute", readColorControlColorTempPhysicalMaxAttributeInteractionInfo); - Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCoupleColorTempToLevelMinMiredsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCoupleColorTempToLevelMinMiredsCommandParams - ); - readColorControlInteractionInfo.put("readCoupleColorTempToLevelMinMiredsAttribute", readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); - Map readColorControlStartUpColorTemperatureMiredsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readStartUpColorTemperatureMiredsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlStartUpColorTemperatureMiredsCommandParams - ); - readColorControlInteractionInfo.put("readStartUpColorTemperatureMiredsAttribute", readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); - Map readColorControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ColorControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), - readColorControlAttributeListCommandParams - ); - readColorControlInteractionInfo.put("readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); - Map readColorControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlClusterRevisionCommandParams - ); - readColorControlInteractionInfo.put("readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("colorControl", readColorControlInteractionInfo); - Map readContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map readContentLauncherAcceptHeaderListCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherAcceptHeaderListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readAcceptHeaderListAttribute( - ( ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback(), - readContentLauncherAcceptHeaderListCommandParams - ); - readContentLauncherInteractionInfo.put("readAcceptHeaderListAttribute", readContentLauncherAcceptHeaderListAttributeInteractionInfo); - Map readContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readSupportedStreamingProtocolsAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readColorControlCompensationTextCommandParams); + readColorControlInteractionInfo.put( + "readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); + Map readColorControlColorTemperatureCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTemperatureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTemperatureCommandParams); + readColorControlInteractionInfo.put( + "readColorTemperatureAttribute", readColorControlColorTemperatureAttributeInteractionInfo); + Map readColorControlColorModeCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorModeCommandParams); + readColorControlInteractionInfo.put( + "readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); + Map readColorControlColorControlOptionsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorControlOptionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorControlOptionsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorControlOptionsCommandParams); + readColorControlInteractionInfo.put( + "readColorControlOptionsAttribute", + readColorControlColorControlOptionsAttributeInteractionInfo); + Map readColorControlNumberOfPrimariesCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readNumberOfPrimariesAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlNumberOfPrimariesCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); + Map readColorControlPrimary1IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary1IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary1IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); + Map readColorControlPrimary2IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary2IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary2IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); + Map readColorControlPrimary3IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary3IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary3IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); + Map readColorControlPrimary4IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary4IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary4IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); + Map readColorControlPrimary5IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary5IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary5IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); + Map readColorControlPrimary6IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary6IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary6IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); + Map readColorControlColorPointRIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointRIntensityAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointRIntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); + Map readColorControlColorPointGIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointGIntensityAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointGIntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); + Map readColorControlColorPointBIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointBIntensityAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointBIntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorCapabilitiesAttribute", + readColorControlColorCapabilitiesAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMinCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTempPhysicalMinAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMinCommandParams); + readColorControlInteractionInfo.put( + "readColorTempPhysicalMinAttribute", + readColorControlColorTempPhysicalMinAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTempPhysicalMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMaxCommandParams); + readColorControlInteractionInfo.put( + "readColorTempPhysicalMaxAttribute", + readColorControlColorTempPhysicalMaxAttributeInteractionInfo); + Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCoupleColorTempToLevelMinMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCoupleColorTempToLevelMinMiredsCommandParams); + readColorControlInteractionInfo.put( + "readCoupleColorTempToLevelMinMiredsAttribute", + readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); + Map readColorControlStartUpColorTemperatureMiredsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readStartUpColorTemperatureMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlStartUpColorTemperatureMiredsCommandParams); + readColorControlInteractionInfo.put( + "readStartUpColorTemperatureMiredsAttribute", + readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); + Map readColorControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ColorControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), + readColorControlAttributeListCommandParams); + readColorControlInteractionInfo.put( + "readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); + Map readColorControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlClusterRevisionCommandParams); + readColorControlInteractionInfo.put( + "readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("colorControl", readColorControlInteractionInfo); + Map readContentLauncherInteractionInfo = new LinkedHashMap<>(); + Map readContentLauncherAcceptHeaderListCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherAcceptHeaderListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readAcceptHeaderListAttribute( + (ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback(), + readContentLauncherAcceptHeaderListCommandParams); + readContentLauncherInteractionInfo.put( + "readAcceptHeaderListAttribute", + readContentLauncherAcceptHeaderListAttributeInteractionInfo); + Map readContentLauncherSupportedStreamingProtocolsCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readSupportedStreamingProtocolsAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readContentLauncherSupportedStreamingProtocolsCommandParams - ); - readContentLauncherInteractionInfo.put("readSupportedStreamingProtocolsAttribute", readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); - Map readContentLauncherAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAttributeListAttributeCallback(), - readContentLauncherAttributeListCommandParams - ); - readContentLauncherInteractionInfo.put("readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); - Map readContentLauncherClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readContentLauncherClusterRevisionCommandParams - ); - readContentLauncherInteractionInfo.put("readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("contentLauncher", readContentLauncherInteractionInfo); - Map readDescriptorInteractionInfo = new LinkedHashMap<>(); - Map readDescriptorDeviceListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorDeviceListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readDeviceListAttribute( - ( ChipClusters.DescriptorCluster.DeviceListAttributeCallback - ) callback - ); - }, + readContentLauncherSupportedStreamingProtocolsCommandParams); + readContentLauncherInteractionInfo.put( + "readSupportedStreamingProtocolsAttribute", + readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); + Map readContentLauncherAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedContentLauncherClusterAttributeListAttributeCallback(), + readContentLauncherAttributeListCommandParams); + readContentLauncherInteractionInfo.put( + "readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); + Map readContentLauncherClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readContentLauncherClusterRevisionCommandParams); + readContentLauncherInteractionInfo.put( + "readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("contentLauncher", readContentLauncherInteractionInfo); + Map readDescriptorInteractionInfo = new LinkedHashMap<>(); + Map readDescriptorDeviceListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorDeviceListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readDeviceListAttribute( + (ChipClusters.DescriptorCluster.DeviceListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterDeviceListAttributeCallback(), - readDescriptorDeviceListCommandParams - ); - readDescriptorInteractionInfo.put("readDeviceListAttribute", readDescriptorDeviceListAttributeInteractionInfo); - Map readDescriptorServerListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorServerListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readServerListAttribute( - ( ChipClusters.DescriptorCluster.ServerListAttributeCallback - ) callback - ); - }, + readDescriptorDeviceListCommandParams); + readDescriptorInteractionInfo.put( + "readDeviceListAttribute", readDescriptorDeviceListAttributeInteractionInfo); + Map readDescriptorServerListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorServerListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readServerListAttribute( + (ChipClusters.DescriptorCluster.ServerListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterServerListAttributeCallback(), - readDescriptorServerListCommandParams - ); - readDescriptorInteractionInfo.put("readServerListAttribute", readDescriptorServerListAttributeInteractionInfo); - Map readDescriptorClientListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorClientListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readClientListAttribute( - ( ChipClusters.DescriptorCluster.ClientListAttributeCallback - ) callback - ); - }, + readDescriptorServerListCommandParams); + readDescriptorInteractionInfo.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 - ); - readDescriptorInteractionInfo.put("readClientListAttribute", readDescriptorClientListAttributeInteractionInfo); - Map readDescriptorPartsListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorPartsListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readPartsListAttribute( - ( ChipClusters.DescriptorCluster.PartsListAttributeCallback - ) callback - ); - }, + readDescriptorClientListCommandParams); + readDescriptorInteractionInfo.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 - ); - readDescriptorInteractionInfo.put("readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); - Map readDescriptorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readAttributeListAttribute( - ( ChipClusters.DescriptorCluster.AttributeListAttributeCallback - ) callback - ); - }, + readDescriptorPartsListCommandParams); + readDescriptorInteractionInfo.put( + "readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); + Map readDescriptorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DescriptorCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterAttributeListAttributeCallback(), - readDescriptorAttributeListCommandParams - ); - readDescriptorInteractionInfo.put("readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); - Map readDescriptorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDescriptorClusterRevisionCommandParams - ); - readDescriptorInteractionInfo.put("readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("descriptor", readDescriptorInteractionInfo); - Map readDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); - Map readDiagnosticLogsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), - readDiagnosticLogsAttributeListCommandParams - ); - readDiagnosticLogsInteractionInfo.put("readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); - readAttributeMap.put("diagnosticLogs", readDiagnosticLogsInteractionInfo); - Map readDoorLockInteractionInfo = new LinkedHashMap<>(); - Map readDoorLockLockStateCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockLockStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readLockStateAttribute( - ( ChipClusters.DoorLockCluster.LockStateAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockLockStateCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readLockTypeAttribute", readDoorLockLockTypeAttributeInteractionInfo); - Map readDoorLockActuatorEnabledCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockActuatorEnabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readActuatorEnabledAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readDescriptorAttributeListCommandParams); + readDescriptorInteractionInfo.put( + "readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); + Map readDescriptorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDescriptorClusterRevisionCommandParams); + readDescriptorInteractionInfo.put( + "readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("descriptor", readDescriptorInteractionInfo); + Map readDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); + Map readDiagnosticLogsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), + readDiagnosticLogsAttributeListCommandParams); + readDiagnosticLogsInteractionInfo.put( + "readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); + readAttributeMap.put("diagnosticLogs", readDiagnosticLogsInteractionInfo); + Map readDoorLockInteractionInfo = new LinkedHashMap<>(); + Map readDoorLockLockStateCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockLockStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readLockStateAttribute( + (ChipClusters.DoorLockCluster.LockStateAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockLockStateCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); - Map readDoorLockDoorStateCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readDoorStateAttribute( - ( ChipClusters.DoorLockCluster.DoorStateAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockDoorStateCommandParams - ); - readDoorLockInteractionInfo.put("readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); - Map readDoorLockNumberOfTotalUsersSupportedCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readNumberOfTotalUsersSupportedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfTotalUsersSupportedCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readNumberOfYearDaySchedulesSupportedPerUserAttribute", readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); - Map readDoorLockMaxPINCodeLengthCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readMaxPINCodeLengthAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMaxPINCodeLengthCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); - Map readDoorLockLanguageCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockLanguageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readLanguageAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readDoorLockActuatorEnabledCommandParams); + readDoorLockInteractionInfo.put( + "readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); + Map readDoorLockDoorStateCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readDoorStateAttribute( + (ChipClusters.DoorLockCluster.DoorStateAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockDoorStateCommandParams); + readDoorLockInteractionInfo.put( + "readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); + Map readDoorLockNumberOfTotalUsersSupportedCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readNumberOfTotalUsersSupportedAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfTotalUsersSupportedCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.put( + "readNumberOfYearDaySchedulesSupportedPerUserAttribute", + readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); + Map readDoorLockMaxPINCodeLengthCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readMaxPINCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMaxPINCodeLengthCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.put( + "readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); + Map readDoorLockLanguageCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockLanguageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readLanguageAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readDoorLockLanguageCommandParams - ); - readDoorLockInteractionInfo.put("readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); - Map readDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readAutoRelockTimeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readDoorLockLanguageCommandParams); + readDoorLockInteractionInfo.put( + "readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); + Map readDoorLockAutoRelockTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readAutoRelockTimeAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockAutoRelockTimeCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readSupportedOperatingModesAttribute", readDoorLockSupportedOperatingModesAttributeInteractionInfo); - Map readDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readEnableOneTouchLockingAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readDoorLockAutoRelockTimeCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.put( + "readSupportedOperatingModesAttribute", + readDoorLockSupportedOperatingModesAttributeInteractionInfo); + Map readDoorLockEnableOneTouchLockingCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readEnableOneTouchLockingAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnableOneTouchLockingCommandParams - ); - readDoorLockInteractionInfo.put("readEnableOneTouchLockingAttribute", readDoorLockEnableOneTouchLockingAttributeInteractionInfo); - Map readDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readEnablePrivacyModeButtonAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readDoorLockEnableOneTouchLockingCommandParams); + readDoorLockInteractionInfo.put( + "readEnableOneTouchLockingAttribute", + readDoorLockEnableOneTouchLockingAttributeInteractionInfo); + Map readDoorLockEnablePrivacyModeButtonCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readEnablePrivacyModeButtonAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnablePrivacyModeButtonCommandParams - ); - readDoorLockInteractionInfo.put("readEnablePrivacyModeButtonAttribute", readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); - Map readDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readWrongCodeEntryLimitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockWrongCodeEntryLimitCommandParams - ); - readDoorLockInteractionInfo.put("readWrongCodeEntryLimitAttribute", readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); - Map readDoorLockAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readAttributeListAttribute( - ( ChipClusters.DoorLockCluster.AttributeListAttributeCallback - ) callback - ); - }, + readDoorLockEnablePrivacyModeButtonCommandParams); + readDoorLockInteractionInfo.put( + "readEnablePrivacyModeButtonAttribute", + readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); + Map readDoorLockWrongCodeEntryLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readWrongCodeEntryLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockWrongCodeEntryLimitCommandParams); + readDoorLockInteractionInfo.put( + "readWrongCodeEntryLimitAttribute", + readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); + Map readDoorLockAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DoorLockCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDoorLockClusterAttributeListAttributeCallback(), - readDoorLockAttributeListCommandParams - ); - readDoorLockInteractionInfo.put("readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); - Map readDoorLockClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockClusterRevisionCommandParams - ); - readDoorLockInteractionInfo.put("readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("doorLock", readDoorLockInteractionInfo); - Map readElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readElectricalMeasurementMeasurementTypeCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasurementTypeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readDoorLockAttributeListCommandParams); + readDoorLockInteractionInfo.put( + "readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); + Map readDoorLockClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockClusterRevisionCommandParams); + readDoorLockInteractionInfo.put( + "readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("doorLock", readDoorLockInteractionInfo); + Map readElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readElectricalMeasurementMeasurementTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasurementTypeAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementMeasurementTypeCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readMeasurementTypeAttribute", readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); - Map readElectricalMeasurementTotalActivePowerCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readTotalActivePowerAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readElectricalMeasurementMeasurementTypeCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readMeasurementTypeAttribute", + readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); + Map readElectricalMeasurementTotalActivePowerCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readTotalActivePowerAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementTotalActivePowerCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readTotalActivePowerAttribute", readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageCommandParams - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.put("readActivePowerMaxAttribute", readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); - Map readElectricalMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), - readElectricalMeasurementAttributeListCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readAttributeListAttribute", readElectricalMeasurementAttributeListAttributeInteractionInfo); - Map readElectricalMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementClusterRevisionCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readClusterRevisionAttribute", readElectricalMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("electricalMeasurement", readElectricalMeasurementInteractionInfo); - Map readEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - Map readEthernetNetworkDiagnosticsPHYRateCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPHYRateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readEthernetNetworkDiagnosticsPHYRateCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFullDuplexAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readElectricalMeasurementTotalActivePowerCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readTotalActivePowerAttribute", + readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageCommandParams); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.put( + "readActivePowerMaxAttribute", + readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); + Map readElectricalMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), + readElectricalMeasurementAttributeListCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readElectricalMeasurementAttributeListAttributeInteractionInfo); + Map readElectricalMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementClusterRevisionCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readElectricalMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("electricalMeasurement", readElectricalMeasurementInteractionInfo); + Map readEthernetNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + Map readEthernetNetworkDiagnosticsPHYRateCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readPHYRateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthernetNetworkDiagnosticsPHYRateCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readFullDuplexAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readEthernetNetworkDiagnosticsFullDuplexCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readFullDuplexAttribute", readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPacketRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsFullDuplexCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readPacketRxCountAttribute", readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPacketTxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsPacketRxCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readPacketTxCountAttribute", readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTxErrCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readTxErrCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsPacketTxCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readTxErrCountAttribute", readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCollisionCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCollisionCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsTxErrCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readCollisionCountAttribute", readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsCollisionCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCarrierDetectAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsOverrunCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readOverrunCountAttribute", + readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readCarrierDetectAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readEthernetNetworkDiagnosticsCarrierDetectCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readCarrierDetectAttribute", readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTimeSinceResetCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readTimeSinceResetAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsCarrierDetectCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readTimeSinceResetAttribute", readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.EthernetNetworkDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readEthernetNetworkDiagnosticsAttributeListCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readAttributeListAttribute", readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsTimeSinceResetCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readTimeSinceResetAttribute", + readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readEthernetNetworkDiagnosticsAttributeListCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo); - Map readFixedLabelInteractionInfo = new LinkedHashMap<>(); - Map readFixedLabelLabelListCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelLabelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readLabelListAttribute( - ( ChipClusters.FixedLabelCluster.LabelListAttributeCallback - ) callback - ); - }, + readEthernetNetworkDiagnosticsFeatureMapCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo); + Map readFixedLabelInteractionInfo = 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 - ); - readFixedLabelInteractionInfo.put("readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); - Map readFixedLabelAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readAttributeListAttribute( - ( ChipClusters.FixedLabelCluster.AttributeListAttributeCallback - ) callback - ); - }, + readFixedLabelLabelListCommandParams); + readFixedLabelInteractionInfo.put( + "readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); + Map readFixedLabelAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.FixedLabelCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedFixedLabelClusterAttributeListAttributeCallback(), - readFixedLabelAttributeListCommandParams - ); - readFixedLabelInteractionInfo.put("readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); - Map readFixedLabelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFixedLabelClusterRevisionCommandParams - ); - readFixedLabelInteractionInfo.put("readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("fixedLabel", readFixedLabelInteractionInfo); - Map readFlowMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readFlowMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMeasuredValueCommandParams - ); - readFlowMeasurementInteractionInfo.put("readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMinMeasuredValueCommandParams - ); - readFlowMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMaxMeasuredValueCommandParams - ); - readFlowMeasurementInteractionInfo.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 - ); - readFlowMeasurementInteractionInfo.put("readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); - Map readFlowMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), - readFlowMeasurementAttributeListCommandParams - ); - readFlowMeasurementInteractionInfo.put("readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); - Map readFlowMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementClusterRevisionCommandParams - ); - readFlowMeasurementInteractionInfo.put("readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("flowMeasurement", readFlowMeasurementInteractionInfo); - Map readGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readBreadcrumbAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readFixedLabelAttributeListCommandParams); + readFixedLabelInteractionInfo.put( + "readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); + Map readFixedLabelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFixedLabelClusterRevisionCommandParams); + readFixedLabelInteractionInfo.put( + "readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("fixedLabel", readFixedLabelInteractionInfo); + Map readFlowMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readFlowMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMeasuredValueCommandParams); + readFlowMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMinMeasuredValueCommandParams); + readFlowMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMaxMeasuredValueCommandParams); + readFlowMeasurementInteractionInfo.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); + readFlowMeasurementInteractionInfo.put( + "readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); + Map readFlowMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), + readFlowMeasurementAttributeListCommandParams); + readFlowMeasurementInteractionInfo.put( + "readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); + Map readFlowMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementClusterRevisionCommandParams); + readFlowMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("flowMeasurement", readFlowMeasurementInteractionInfo); + Map readGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readGeneralCommissioningBreadcrumbCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readBreadcrumbAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralCommissioningBreadcrumbCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); - Map readGeneralCommissioningBasicCommissioningInfoListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readBasicCommissioningInfoListAttribute( - ( ChipClusters.GeneralCommissioningCluster.BasicCommissioningInfoListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback(), - readGeneralCommissioningBasicCommissioningInfoListCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readBasicCommissioningInfoListAttribute", readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo); - Map readGeneralCommissioningRegulatoryConfigCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readRegulatoryConfigAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningRegulatoryConfigCommandParams - ); - readGeneralCommissioningInteractionInfo.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 - ); - readGeneralCommissioningInteractionInfo.put("readLocationCapabilityAttribute", readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); - Map readGeneralCommissioningAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), - readGeneralCommissioningAttributeListCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readAttributeListAttribute", readGeneralCommissioningAttributeListAttributeInteractionInfo); - Map readGeneralCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningClusterRevisionCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readClusterRevisionAttribute", readGeneralCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("generalCommissioning", readGeneralCommissioningInteractionInfo); - Map readGeneralDiagnosticsInteractionInfo = 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 - ); - readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readRebootCountAttribute", readGeneralDiagnosticsRebootCountAttributeInteractionInfo); - Map readGeneralDiagnosticsUpTimeCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsUpTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readUpTimeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readGeneralCommissioningBreadcrumbCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); + Map + readGeneralCommissioningBasicCommissioningInfoListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readBasicCommissioningInfoListAttribute( + (ChipClusters.GeneralCommissioningCluster + .BasicCommissioningInfoListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback(), + readGeneralCommissioningBasicCommissioningInfoListCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readBasicCommissioningInfoListAttribute", + readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo); + Map readGeneralCommissioningRegulatoryConfigCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readRegulatoryConfigAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningRegulatoryConfigCommandParams); + readGeneralCommissioningInteractionInfo.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); + readGeneralCommissioningInteractionInfo.put( + "readLocationCapabilityAttribute", + readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); + Map readGeneralCommissioningAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), + readGeneralCommissioningAttributeListCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readAttributeListAttribute", + readGeneralCommissioningAttributeListAttributeInteractionInfo); + Map readGeneralCommissioningClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningClusterRevisionCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readClusterRevisionAttribute", + readGeneralCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalCommissioning", readGeneralCommissioningInteractionInfo); + Map readGeneralDiagnosticsInteractionInfo = 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); + readGeneralDiagnosticsInteractionInfo.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); + readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readUpTimeAttribute", readGeneralDiagnosticsUpTimeAttributeInteractionInfo); - Map readGeneralDiagnosticsTotalOperationalHoursCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readTotalOperationalHoursAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readGeneralDiagnosticsUpTimeCommandParams); + readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readTotalOperationalHoursAttribute", readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); - Map readGeneralDiagnosticsBootReasonsCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsBootReasonsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readBootReasonsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsBootReasonsCommandParams - ); - readGeneralDiagnosticsInteractionInfo.put("readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeInteractionInfo); - Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readActiveHardwareFaultsAttribute( - ( ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), - readGeneralDiagnosticsActiveHardwareFaultsCommandParams - ); - readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readActiveNetworkFaultsAttribute", readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); - Map readGeneralDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), - readGeneralDiagnosticsAttributeListCommandParams - ); - readGeneralDiagnosticsInteractionInfo.put("readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); - Map readGeneralDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsClusterRevisionCommandParams - ); - readGeneralDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo); - Map readGroupKeyManagementInteractionInfo = 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 - ); - readGroupKeyManagementInteractionInfo.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 - ); - readGroupKeyManagementInteractionInfo.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 - ); - readGroupKeyManagementInteractionInfo.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 - ); - readGroupKeyManagementInteractionInfo.put("readMaxGroupKeysPerFabricAttribute", readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); - Map readGroupKeyManagementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), - readGroupKeyManagementAttributeListCommandParams - ); - readGroupKeyManagementInteractionInfo.put("readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); - Map readGroupKeyManagementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupKeyManagementClusterRevisionCommandParams - ); - readGroupKeyManagementInteractionInfo.put("readClusterRevisionAttribute", readGroupKeyManagementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("groupKeyManagement", readGroupKeyManagementInteractionInfo); - Map readGroupsInteractionInfo = new LinkedHashMap<>(); - Map readGroupsNameSupportCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsNameSupportAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readNameSupportAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsNameSupportCommandParams - ); - readGroupsInteractionInfo.put("readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); - Map readGroupsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GroupsCluster.AttributeListAttributeCallback - ) callback - ); - }, + readGeneralDiagnosticsTotalOperationalHoursCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readTotalOperationalHoursAttribute", + readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); + Map readGeneralDiagnosticsBootReasonsCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsBootReasonsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readBootReasonsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsBootReasonsCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeInteractionInfo); + Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readActiveHardwareFaultsAttribute( + (ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), + readGeneralDiagnosticsActiveHardwareFaultsCommandParams); + readGeneralDiagnosticsInteractionInfo.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); + readGeneralDiagnosticsInteractionInfo.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); + readGeneralDiagnosticsInteractionInfo.put( + "readActiveNetworkFaultsAttribute", + readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); + Map readGeneralDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), + readGeneralDiagnosticsAttributeListCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); + Map readGeneralDiagnosticsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsClusterRevisionCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo); + Map readGroupKeyManagementInteractionInfo = 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); + readGroupKeyManagementInteractionInfo.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); + readGroupKeyManagementInteractionInfo.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); + readGroupKeyManagementInteractionInfo.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); + readGroupKeyManagementInteractionInfo.put( + "readMaxGroupKeysPerFabricAttribute", + readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); + Map readGroupKeyManagementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), + readGroupKeyManagementAttributeListCommandParams); + readGroupKeyManagementInteractionInfo.put( + "readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); + Map readGroupKeyManagementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupKeyManagementClusterRevisionCommandParams); + readGroupKeyManagementInteractionInfo.put( + "readClusterRevisionAttribute", + readGroupKeyManagementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groupKeyManagement", readGroupKeyManagementInteractionInfo); + Map readGroupsInteractionInfo = new LinkedHashMap<>(); + Map readGroupsNameSupportCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsNameSupportAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readNameSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsNameSupportCommandParams); + readGroupsInteractionInfo.put( + "readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); + Map readGroupsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GroupsCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedGroupsClusterAttributeListAttributeCallback(), - readGroupsAttributeListCommandParams - ); - readGroupsInteractionInfo.put("readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); - Map readGroupsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsClusterRevisionCommandParams - ); - readGroupsInteractionInfo.put("readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("groups", readGroupsInteractionInfo); - Map readIdentifyInteractionInfo = new LinkedHashMap<>(); - Map readIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readIdentifyTimeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyIdentifyTimeCommandParams - ); - readIdentifyInteractionInfo.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 - ); - readIdentifyInteractionInfo.put("readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); - Map readIdentifyAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readAttributeListAttribute( - ( ChipClusters.IdentifyCluster.AttributeListAttributeCallback - ) callback - ); - }, + readGroupsAttributeListCommandParams); + readGroupsInteractionInfo.put( + "readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); + Map readGroupsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsClusterRevisionCommandParams); + readGroupsInteractionInfo.put( + "readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groups", readGroupsInteractionInfo); + Map readIdentifyInteractionInfo = new LinkedHashMap<>(); + Map readIdentifyIdentifyTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readIdentifyTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyIdentifyTimeCommandParams); + readIdentifyInteractionInfo.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); + readIdentifyInteractionInfo.put( + "readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); + Map readIdentifyAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.IdentifyCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedIdentifyClusterAttributeListAttributeCallback(), - readIdentifyAttributeListCommandParams - ); - readIdentifyInteractionInfo.put("readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); - Map readIdentifyClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyClusterRevisionCommandParams - ); - readIdentifyInteractionInfo.put("readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("identify", readIdentifyInteractionInfo); - Map readIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readIlluminanceMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMeasuredValueAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMeasuredValueCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readMeasuredValueAttribute", readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMinMeasuredValueCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMaxMeasuredValueCommandParams - ); - readIlluminanceMeasurementInteractionInfo.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 - ); - readIlluminanceMeasurementInteractionInfo.put("readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); - Map readIlluminanceMeasurementLightSensorTypeCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readLightSensorTypeAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementLightSensorTypeCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readLightSensorTypeAttribute", readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); - Map readIlluminanceMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), - readIlluminanceMeasurementAttributeListCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readAttributeListAttribute", readIlluminanceMeasurementAttributeListAttributeInteractionInfo); - Map readIlluminanceMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementClusterRevisionCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readClusterRevisionAttribute", readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo); - Map readKeypadInputInteractionInfo = new LinkedHashMap<>(); - Map readKeypadInputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readAttributeListAttribute( - ( ChipClusters.KeypadInputCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), - readKeypadInputAttributeListCommandParams - ); - readKeypadInputInteractionInfo.put("readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); - Map readKeypadInputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readKeypadInputClusterRevisionCommandParams - ); - readKeypadInputInteractionInfo.put("readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("keypadInput", readKeypadInputInteractionInfo); - Map readLevelControlInteractionInfo = new LinkedHashMap<>(); - Map readLevelControlCurrentLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readCurrentLevelAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlCurrentLevelCommandParams - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.put("readOnOffTransitionTimeAttribute", readLevelControlOnOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlOnLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOnLevelAttribute( - ( ChipClusters.LevelControlCluster.OnLevelAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnLevelCommandParams - ); - readLevelControlInteractionInfo.put("readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); - Map readLevelControlOnTransitionTimeCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOnTransitionTimeAttribute( - ( ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnTransitionTimeCommandParams - ); - readLevelControlInteractionInfo.put("readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); - Map readLevelControlOffTransitionTimeCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOffTransitionTimeAttribute( - ( ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOffTransitionTimeCommandParams - ); - readLevelControlInteractionInfo.put("readOffTransitionTimeAttribute", readLevelControlOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlDefaultMoveRateCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readDefaultMoveRateAttribute( - ( ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlDefaultMoveRateCommandParams - ); - readLevelControlInteractionInfo.put("readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); - Map readLevelControlStartUpCurrentLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readStartUpCurrentLevelAttribute( - ( ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlStartUpCurrentLevelCommandParams - ); - readLevelControlInteractionInfo.put("readStartUpCurrentLevelAttribute", readLevelControlStartUpCurrentLevelAttributeInteractionInfo); - Map readLevelControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.LevelControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), - readLevelControlAttributeListCommandParams - ); - readLevelControlInteractionInfo.put("readAttributeListAttribute", readLevelControlAttributeListAttributeInteractionInfo); - Map readLevelControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readIdentifyAttributeListCommandParams); + readIdentifyInteractionInfo.put( + "readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); + Map readIdentifyClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyClusterRevisionCommandParams); + readIdentifyInteractionInfo.put( + "readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("identify", readIdentifyInteractionInfo); + Map readIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readIlluminanceMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMeasuredValueCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", + readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMinMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMinMeasuredValueCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMaxMeasuredValueCommandParams); + readIlluminanceMeasurementInteractionInfo.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); + readIlluminanceMeasurementInteractionInfo.put( + "readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); + Map readIlluminanceMeasurementLightSensorTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readLightSensorTypeAttribute( + (ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementLightSensorTypeCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readLightSensorTypeAttribute", + readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); + Map readIlluminanceMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), + readIlluminanceMeasurementAttributeListCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readIlluminanceMeasurementAttributeListAttributeInteractionInfo); + Map readIlluminanceMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementClusterRevisionCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo); + Map readKeypadInputInteractionInfo = new LinkedHashMap<>(); + Map readKeypadInputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.KeypadInputCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), + readKeypadInputAttributeListCommandParams); + readKeypadInputInteractionInfo.put( + "readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); + Map readKeypadInputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readKeypadInputClusterRevisionCommandParams); + readKeypadInputInteractionInfo.put( + "readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("keypadInput", readKeypadInputInteractionInfo); + Map readLevelControlInteractionInfo = new LinkedHashMap<>(); + Map readLevelControlCurrentLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readCurrentLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlCurrentLevelCommandParams); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.put( + "readOnOffTransitionTimeAttribute", + readLevelControlOnOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlOnLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOnLevelAttribute( + (ChipClusters.LevelControlCluster.OnLevelAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnLevelCommandParams); + readLevelControlInteractionInfo.put( + "readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); + Map readLevelControlOnTransitionTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOnTransitionTimeAttribute( + (ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnTransitionTimeCommandParams); + readLevelControlInteractionInfo.put( + "readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); + Map readLevelControlOffTransitionTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOffTransitionTimeAttribute( + (ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOffTransitionTimeCommandParams); + readLevelControlInteractionInfo.put( + "readOffTransitionTimeAttribute", + readLevelControlOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlDefaultMoveRateCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readDefaultMoveRateAttribute( + (ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlDefaultMoveRateCommandParams); + readLevelControlInteractionInfo.put( + "readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); + Map readLevelControlStartUpCurrentLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readStartUpCurrentLevelAttribute( + (ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlStartUpCurrentLevelCommandParams); + readLevelControlInteractionInfo.put( + "readStartUpCurrentLevelAttribute", + readLevelControlStartUpCurrentLevelAttributeInteractionInfo); + Map readLevelControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.LevelControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), + readLevelControlAttributeListCommandParams); + readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.put("readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("levelControl", readLevelControlInteractionInfo); - Map readLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); - Map readLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readActiveLocaleAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readLevelControlFeatureMapCommandParams); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.put( + "readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("levelControl", readLevelControlInteractionInfo); + Map readLocalizationConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map readLocalizationConfigurationActiveLocaleCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readActiveLocaleAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readLocalizationConfigurationActiveLocaleCommandParams - ); - readLocalizationConfigurationInteractionInfo.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 - ); - readLocalizationConfigurationInteractionInfo.put("readSupportedLocalesAttribute", readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); - Map readLocalizationConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLocalizationConfigurationClusterRevisionCommandParams - ); - readLocalizationConfigurationInteractionInfo.put("readClusterRevisionAttribute", readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("localizationConfiguration", readLocalizationConfigurationInteractionInfo); - Map readLowPowerInteractionInfo = new LinkedHashMap<>(); - Map readLowPowerAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readAttributeListAttribute( - ( ChipClusters.LowPowerCluster.AttributeListAttributeCallback - ) callback - ); - }, + readLocalizationConfigurationActiveLocaleCommandParams); + readLocalizationConfigurationInteractionInfo.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); + readLocalizationConfigurationInteractionInfo.put( + "readSupportedLocalesAttribute", + readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); + Map readLocalizationConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLocalizationConfigurationClusterRevisionCommandParams); + readLocalizationConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("localizationConfiguration", readLocalizationConfigurationInteractionInfo); + Map readLowPowerInteractionInfo = new LinkedHashMap<>(); + Map readLowPowerAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.LowPowerCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLowPowerClusterAttributeListAttributeCallback(), - readLowPowerAttributeListCommandParams - ); - readLowPowerInteractionInfo.put("readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); - Map readLowPowerClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLowPowerClusterRevisionCommandParams - ); - readLowPowerInteractionInfo.put("readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("lowPower", readLowPowerInteractionInfo); - Map readMediaInputInteractionInfo = new LinkedHashMap<>(); - Map readMediaInputMediaInputListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputMediaInputListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readMediaInputListAttribute( - ( ChipClusters.MediaInputCluster.MediaInputListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaInputClusterMediaInputListAttributeCallback(), - readMediaInputMediaInputListCommandParams - ); - readMediaInputInteractionInfo.put("readMediaInputListAttribute", readMediaInputMediaInputListAttributeInteractionInfo); - Map readMediaInputCurrentMediaInputCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputCurrentMediaInputAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readCurrentMediaInputAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputCurrentMediaInputCommandParams - ); - readMediaInputInteractionInfo.put("readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeInteractionInfo); - Map readMediaInputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readAttributeListAttribute( - ( ChipClusters.MediaInputCluster.AttributeListAttributeCallback - ) callback - ); - }, + readLowPowerAttributeListCommandParams); + readLowPowerInteractionInfo.put( + "readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); + Map readLowPowerClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLowPowerClusterRevisionCommandParams); + readLowPowerInteractionInfo.put( + "readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("lowPower", readLowPowerInteractionInfo); + Map readMediaInputInteractionInfo = new LinkedHashMap<>(); + Map readMediaInputMediaInputListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputMediaInputListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readMediaInputListAttribute( + (ChipClusters.MediaInputCluster.MediaInputListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedMediaInputClusterMediaInputListAttributeCallback(), + readMediaInputMediaInputListCommandParams); + readMediaInputInteractionInfo.put( + "readMediaInputListAttribute", readMediaInputMediaInputListAttributeInteractionInfo); + Map readMediaInputCurrentMediaInputCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputCurrentMediaInputAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readCurrentMediaInputAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputCurrentMediaInputCommandParams); + readMediaInputInteractionInfo.put( + "readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeInteractionInfo); + Map readMediaInputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.MediaInputCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedMediaInputClusterAttributeListAttributeCallback(), - readMediaInputAttributeListCommandParams - ); - readMediaInputInteractionInfo.put("readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); - Map readMediaInputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputClusterRevisionCommandParams - ); - readMediaInputInteractionInfo.put("readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("mediaInput", readMediaInputInteractionInfo); - Map readMediaPlaybackInteractionInfo = new LinkedHashMap<>(); - Map readMediaPlaybackPlaybackStateCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readPlaybackStateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackPlaybackStateCommandParams - ); - readMediaPlaybackInteractionInfo.put("readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeInteractionInfo); - Map readMediaPlaybackStartTimeCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readStartTimeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaInputAttributeListCommandParams); + readMediaInputInteractionInfo.put( + "readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); + Map readMediaInputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputClusterRevisionCommandParams); + readMediaInputInteractionInfo.put( + "readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaInput", readMediaInputInteractionInfo); + Map readMediaPlaybackInteractionInfo = new LinkedHashMap<>(); + Map readMediaPlaybackPlaybackStateCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackPlaybackStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readPlaybackStateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackPlaybackStateCommandParams); + readMediaPlaybackInteractionInfo.put( + "readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeInteractionInfo); + Map readMediaPlaybackStartTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readStartTimeAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackStartTimeCommandParams - ); - readMediaPlaybackInteractionInfo.put("readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); - Map readMediaPlaybackDurationCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readDurationAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaPlaybackStartTimeCommandParams); + readMediaPlaybackInteractionInfo.put( + "readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); + Map readMediaPlaybackDurationCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readDurationAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackDurationCommandParams - ); - readMediaPlaybackInteractionInfo.put("readDurationAttribute", readMediaPlaybackDurationAttributeInteractionInfo); - Map readMediaPlaybackPlaybackSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readPlaybackSpeedAttribute( - ( - ChipClusters.FloatAttributeCallback -) callback - ); - }, + readMediaPlaybackDurationCommandParams); + readMediaPlaybackInteractionInfo.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 - ); - readMediaPlaybackInteractionInfo.put("readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeEndCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeEndAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaPlaybackPlaybackSpeedCommandParams); + readMediaPlaybackInteractionInfo.put( + "readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeEndCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readSeekRangeEndAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackSeekRangeEndCommandParams - ); - readMediaPlaybackInteractionInfo.put("readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeStartCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeStartAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaPlaybackSeekRangeEndCommandParams); + readMediaPlaybackInteractionInfo.put( + "readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeStartCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readSeekRangeStartAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackSeekRangeStartCommandParams - ); - readMediaPlaybackInteractionInfo.put("readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); - Map readMediaPlaybackAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readAttributeListAttribute( - ( ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), - readMediaPlaybackAttributeListCommandParams - ); - readMediaPlaybackInteractionInfo.put("readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); - Map readMediaPlaybackClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackClusterRevisionCommandParams - ); - readMediaPlaybackInteractionInfo.put("readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("mediaPlayback", readMediaPlaybackInteractionInfo); - Map readModeSelectInteractionInfo = new LinkedHashMap<>(); - Map readModeSelectCurrentModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readCurrentModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectCurrentModeCommandParams - ); - readModeSelectInteractionInfo.put("readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); - Map readModeSelectSupportedModesCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readSupportedModesAttribute( - ( ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), - readModeSelectSupportedModesCommandParams - ); - readModeSelectInteractionInfo.put("readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); - Map readModeSelectOnModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectOnModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readOnModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectOnModeCommandParams - ); - readModeSelectInteractionInfo.put("readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); - Map readModeSelectStartUpModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readStartUpModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectStartUpModeCommandParams - ); - readModeSelectInteractionInfo.put("readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); - Map readModeSelectDescriptionCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readDescriptionAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readMediaPlaybackSeekRangeStartCommandParams); + readMediaPlaybackInteractionInfo.put( + "readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); + Map readMediaPlaybackAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), + readMediaPlaybackAttributeListCommandParams); + readMediaPlaybackInteractionInfo.put( + "readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); + Map readMediaPlaybackClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackClusterRevisionCommandParams); + readMediaPlaybackInteractionInfo.put( + "readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaPlayback", readMediaPlaybackInteractionInfo); + Map readModeSelectInteractionInfo = new LinkedHashMap<>(); + Map readModeSelectCurrentModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readCurrentModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectCurrentModeCommandParams); + readModeSelectInteractionInfo.put( + "readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); + Map readModeSelectSupportedModesCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readSupportedModesAttribute( + (ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), + readModeSelectSupportedModesCommandParams); + readModeSelectInteractionInfo.put( + "readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); + Map readModeSelectOnModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectOnModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readOnModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectOnModeCommandParams); + readModeSelectInteractionInfo.put( + "readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); + Map readModeSelectStartUpModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readStartUpModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectStartUpModeCommandParams); + readModeSelectInteractionInfo.put( + "readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); + Map readModeSelectDescriptionCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readModeSelectDescriptionCommandParams - ); - readModeSelectInteractionInfo.put("readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); - Map readModeSelectAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ModeSelectCluster.AttributeListAttributeCallback - ) callback - ); - }, + readModeSelectDescriptionCommandParams); + readModeSelectInteractionInfo.put( + "readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); + Map readModeSelectAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ModeSelectCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedModeSelectClusterAttributeListAttributeCallback(), - readModeSelectAttributeListCommandParams - ); - readModeSelectInteractionInfo.put("readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); - Map readModeSelectClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectClusterRevisionCommandParams - ); - readModeSelectInteractionInfo.put("readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("modeSelect", readModeSelectInteractionInfo); - Map readNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readNetworkCommissioningMaxNetworksCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readMaxNetworksAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningMaxNetworksCommandParams - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.put("readConnectMaxTimeSecondsAttribute", readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo); - Map readNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readInterfaceEnabledAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readModeSelectAttributeListCommandParams); + readModeSelectInteractionInfo.put( + "readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); + Map readModeSelectClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectClusterRevisionCommandParams); + readModeSelectInteractionInfo.put( + "readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("modeSelect", readModeSelectInteractionInfo); + Map readNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readNetworkCommissioningMaxNetworksCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readMaxNetworksAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningMaxNetworksCommandParams); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.put("readInterfaceEnabledAttribute", readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkingStatusCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkingStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningLastNetworkingStatusCommandParams - ); - readNetworkCommissioningInteractionInfo.put("readLastNetworkingStatusAttribute", readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkIDCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkIDAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readNetworkCommissioningInterfaceEnabledCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readInterfaceEnabledAttribute", + readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkingStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastNetworkingStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningLastNetworkingStatusCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readLastNetworkingStatusAttribute", + readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkIDCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastNetworkIDAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readNetworkCommissioningLastNetworkIDCommandParams - ); - readNetworkCommissioningInteractionInfo.put("readLastNetworkIDAttribute", readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); - Map readNetworkCommissioningLastConnectErrorValueCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastConnectErrorValueAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readNetworkCommissioningLastNetworkIDCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readLastNetworkIDAttribute", + readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); + Map readNetworkCommissioningLastConnectErrorValueCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastConnectErrorValueAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningLastConnectErrorValueCommandParams - ); - readNetworkCommissioningInteractionInfo.put("readLastConnectErrorValueAttribute", readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); - Map readNetworkCommissioningFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readNetworkCommissioningLastConnectErrorValueCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readLastConnectErrorValueAttribute", + readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); + Map readNetworkCommissioningFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningFeatureMapCommandParams - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.put("readClusterRevisionAttribute", readNetworkCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("networkCommissioning", readNetworkCommissioningInteractionInfo); - Map readOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); - Map readOtaSoftwareUpdateProviderAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateProviderAttributeListCommandParams - ); - readOtaSoftwareUpdateProviderInteractionInfo.put("readAttributeListAttribute", readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateProviderClusterRevisionCommandParams - ); - readOtaSoftwareUpdateProviderInteractionInfo.put("readClusterRevisionAttribute", readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo); - Map readOtaSoftwareUpdateRequestorInteractionInfo = 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 - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readDefaultOtaProvidersAttribute", readOtaSoftwareUpdateRequestorDefaultOtaProvidersAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdatePossibleAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readNetworkCommissioningFeatureMapCommandParams); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.put( + "readClusterRevisionAttribute", + readNetworkCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("networkCommissioning", readNetworkCommissioningInteractionInfo); + Map readOtaSoftwareUpdateProviderInteractionInfo = + new LinkedHashMap<>(); + Map readOtaSoftwareUpdateProviderAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateProviderAttributeListCommandParams); + readOtaSoftwareUpdateProviderInteractionInfo.put( + "readAttributeListAttribute", + readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateProviderClusterRevisionCommandParams); + readOtaSoftwareUpdateProviderInteractionInfo.put( + "readClusterRevisionAttribute", + readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo); + Map readOtaSoftwareUpdateRequestorInteractionInfo = + 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); + readOtaSoftwareUpdateRequestorInteractionInfo.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 - ); - readOtaSoftwareUpdateRequestorInteractionInfo.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 - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readUpdateStateAttribute", readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdateStateProgressAttribute( - ( ChipClusters.OtaSoftwareUpdateRequestorCluster.UpdateStateProgressAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readUpdateStateProgressAttribute", readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OtaSoftwareUpdateRequestorCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateRequestorAttributeListCommandParams - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readAttributeListAttribute", readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorClusterRevisionCommandParams - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readClusterRevisionAttribute", readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo); - Map readOccupancySensingInteractionInfo = new LinkedHashMap<>(); - Map readOccupancySensingOccupancyCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readOccupancyAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingOccupancyCommandParams - ); - readOccupancySensingInteractionInfo.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 - ); - readOccupancySensingInteractionInfo.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 - ); - readOccupancySensingInteractionInfo.put("readOccupancySensorTypeBitmapAttribute", readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); - Map readOccupancySensingAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterAttributeListAttributeCallback(), - readOccupancySensingAttributeListCommandParams - ); - readOccupancySensingInteractionInfo.put("readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); - Map readOccupancySensingClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingClusterRevisionCommandParams - ); - readOccupancySensingInteractionInfo.put("readClusterRevisionAttribute", readOccupancySensingClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("occupancySensing", readOccupancySensingInteractionInfo); - Map readOnOffInteractionInfo = new LinkedHashMap<>(); - Map readOnOffOnOffCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffOnOffAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readOnOffAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.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); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readUpdateStateAttribute", + readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); + Map + readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readUpdateStateProgressAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster + .UpdateStateProgressAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readUpdateStateProgressAttribute", + readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateRequestorAttributeListCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readAttributeListAttribute", + readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorClusterRevisionCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readClusterRevisionAttribute", + readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo); + Map readOccupancySensingInteractionInfo = new LinkedHashMap<>(); + Map readOccupancySensingOccupancyCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readOccupancyAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingOccupancyCommandParams); + readOccupancySensingInteractionInfo.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); + readOccupancySensingInteractionInfo.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); + readOccupancySensingInteractionInfo.put( + "readOccupancySensorTypeBitmapAttribute", + readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); + Map readOccupancySensingAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOccupancySensingClusterAttributeListAttributeCallback(), + readOccupancySensingAttributeListCommandParams); + readOccupancySensingInteractionInfo.put( + "readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); + Map readOccupancySensingClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingClusterRevisionCommandParams); + readOccupancySensingInteractionInfo.put( + "readClusterRevisionAttribute", + readOccupancySensingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("occupancySensing", readOccupancySensingInteractionInfo); + Map readOnOffInteractionInfo = new LinkedHashMap<>(); + Map readOnOffOnOffCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffOnOffAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readOnOffAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOnOffOnOffCommandParams - ); - readOnOffInteractionInfo.put("readOnOffAttribute", readOnOffOnOffAttributeInteractionInfo); - Map readOnOffGlobalSceneControlCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffGlobalSceneControlAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readGlobalSceneControlAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readOnOffOnOffCommandParams); + readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.put("readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); - Map readOnOffStartUpOnOffCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readStartUpOnOffAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffStartUpOnOffCommandParams - ); - readOnOffInteractionInfo.put("readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); - Map readOnOffAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OnOffCluster.AttributeListAttributeCallback - ) callback - ); - }, + readOnOffGlobalSceneControlCommandParams); + readOnOffInteractionInfo.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); + readOnOffInteractionInfo.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); + readOnOffInteractionInfo.put( + "readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); + Map readOnOffStartUpOnOffCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readStartUpOnOffAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffStartUpOnOffCommandParams); + readOnOffInteractionInfo.put( + "readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); + Map readOnOffAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OnOffCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOnOffClusterAttributeListAttributeCallback(), - readOnOffAttributeListCommandParams - ); - readOnOffInteractionInfo.put("readAttributeListAttribute", readOnOffAttributeListAttributeInteractionInfo); - Map readOnOffFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readOnOffAttributeListCommandParams); + readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.put("readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("onOff", readOnOffInteractionInfo); - Map readOnOffSwitchConfigurationInteractionInfo = new LinkedHashMap<>(); - Map readOnOffSwitchConfigurationSwitchTypeCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readSwitchTypeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationSwitchTypeCommandParams - ); - readOnOffSwitchConfigurationInteractionInfo.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 - ); - readOnOffSwitchConfigurationInteractionInfo.put("readSwitchActionsAttribute", readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); - Map readOnOffSwitchConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), - readOnOffSwitchConfigurationAttributeListCommandParams - ); - readOnOffSwitchConfigurationInteractionInfo.put("readAttributeListAttribute", readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationClusterRevisionCommandParams - ); - readOnOffSwitchConfigurationInteractionInfo.put("readClusterRevisionAttribute", readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo); - Map readOperationalCredentialsInteractionInfo = 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 - ); - readOperationalCredentialsInteractionInfo.put("readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); - Map readOperationalCredentialsFabricsListCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsFabricsListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readFabricsListAttribute( - ( ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterFabricsListAttributeCallback(), - readOperationalCredentialsFabricsListCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeInteractionInfo); - Map readOperationalCredentialsSupportedFabricsCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readSupportedFabricsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsSupportedFabricsCommandParams - ); - readOperationalCredentialsInteractionInfo.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 - ); - readOperationalCredentialsInteractionInfo.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 - ); - readOperationalCredentialsInteractionInfo.put("readTrustedRootCertificatesAttribute", readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); - Map readOperationalCredentialsCurrentFabricIndexCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readCurrentFabricIndexAttribute( - ( ChipClusters.OperationalCredentialsCluster.CurrentFabricIndexAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsCurrentFabricIndexCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readCurrentFabricIndexAttribute", readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); - Map readOperationalCredentialsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), - readOperationalCredentialsAttributeListCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readAttributeListAttribute", readOperationalCredentialsAttributeListAttributeInteractionInfo); - Map readOperationalCredentialsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsClusterRevisionCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readClusterRevisionAttribute", readOperationalCredentialsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("operationalCredentials", readOperationalCredentialsInteractionInfo); - Map readPowerSourceInteractionInfo = new LinkedHashMap<>(); - Map readPowerSourceStatusCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceStatusCommandParams - ); - readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.put("readOrderAttribute", readPowerSourceOrderAttributeInteractionInfo); - Map readPowerSourceDescriptionCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceDescriptionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readDescriptionAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readOnOffFeatureMapCommandParams); + readOnOffInteractionInfo.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); + readOnOffInteractionInfo.put( + "readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOff", readOnOffInteractionInfo); + Map readOnOffSwitchConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map readOnOffSwitchConfigurationSwitchTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readSwitchTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationSwitchTypeCommandParams); + readOnOffSwitchConfigurationInteractionInfo.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); + readOnOffSwitchConfigurationInteractionInfo.put( + "readSwitchActionsAttribute", + readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); + Map readOnOffSwitchConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), + readOnOffSwitchConfigurationAttributeListCommandParams); + readOnOffSwitchConfigurationInteractionInfo.put( + "readAttributeListAttribute", + readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationClusterRevisionCommandParams); + readOnOffSwitchConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo); + Map readOperationalCredentialsInteractionInfo = 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); + readOperationalCredentialsInteractionInfo.put( + "readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); + Map readOperationalCredentialsFabricsListCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsFabricsListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readFabricsListAttribute( + (ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterFabricsListAttributeCallback(), + readOperationalCredentialsFabricsListCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeInteractionInfo); + Map readOperationalCredentialsSupportedFabricsCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readSupportedFabricsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsSupportedFabricsCommandParams); + readOperationalCredentialsInteractionInfo.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); + readOperationalCredentialsInteractionInfo.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); + readOperationalCredentialsInteractionInfo.put( + "readTrustedRootCertificatesAttribute", + readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); + Map readOperationalCredentialsCurrentFabricIndexCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readCurrentFabricIndexAttribute( + (ChipClusters.OperationalCredentialsCluster + .CurrentFabricIndexAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsCurrentFabricIndexCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readCurrentFabricIndexAttribute", + readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); + Map readOperationalCredentialsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), + readOperationalCredentialsAttributeListCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readAttributeListAttribute", + readOperationalCredentialsAttributeListAttributeInteractionInfo); + Map readOperationalCredentialsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsClusterRevisionCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readClusterRevisionAttribute", + readOperationalCredentialsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("operationalCredentials", readOperationalCredentialsInteractionInfo); + Map readPowerSourceInteractionInfo = new LinkedHashMap<>(); + Map readPowerSourceStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceStatusCommandParams); + readPowerSourceInteractionInfo.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); + readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.put("readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); - Map readPowerSourceBatteryVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryVoltageAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPowerSourceDescriptionCommandParams); + readPowerSourceInteractionInfo.put( + "readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); + Map readPowerSourceBatteryVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryVoltageAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatteryVoltageCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeInteractionInfo); - Map readPowerSourceBatteryPercentRemainingCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryPercentRemainingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryPercentRemainingAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryPercentRemainingCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryPercentRemainingAttribute", readPowerSourceBatteryPercentRemainingAttributeInteractionInfo); - Map readPowerSourceBatteryTimeRemainingCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryTimeRemainingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryTimeRemainingAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPowerSourceBatteryVoltageCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeInteractionInfo); + Map readPowerSourceBatteryPercentRemainingCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryPercentRemainingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryPercentRemainingAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryPercentRemainingCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryPercentRemainingAttribute", + readPowerSourceBatteryPercentRemainingAttributeInteractionInfo); + Map readPowerSourceBatteryTimeRemainingCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryTimeRemainingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryTimeRemainingAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatteryTimeRemainingCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryTimeRemainingAttribute", readPowerSourceBatteryTimeRemainingAttributeInteractionInfo); - Map readPowerSourceBatteryChargeLevelCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryChargeLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryChargeLevelAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryChargeLevelCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryChargeLevelAttribute", readPowerSourceBatteryChargeLevelAttributeInteractionInfo); - Map readPowerSourceActiveBatteryFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceActiveBatteryFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readActiveBatteryFaultsAttribute( - ( ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback(), - readPowerSourceActiveBatteryFaultsCommandParams - ); - readPowerSourceInteractionInfo.put("readActiveBatteryFaultsAttribute", readPowerSourceActiveBatteryFaultsAttributeInteractionInfo); - Map readPowerSourceBatteryChargeStateCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryChargeStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryChargeStateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryChargeStateCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryChargeStateAttribute", readPowerSourceBatteryChargeStateAttributeInteractionInfo); - Map readPowerSourceAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PowerSourceCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), - readPowerSourceAttributeListCommandParams - ); - readPowerSourceInteractionInfo.put("readAttributeListAttribute", readPowerSourceAttributeListAttributeInteractionInfo); - Map readPowerSourceFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPowerSourceBatteryTimeRemainingCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryTimeRemainingAttribute", + readPowerSourceBatteryTimeRemainingAttributeInteractionInfo); + Map readPowerSourceBatteryChargeLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryChargeLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryChargeLevelAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryChargeLevelCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryChargeLevelAttribute", + readPowerSourceBatteryChargeLevelAttributeInteractionInfo); + Map readPowerSourceActiveBatteryFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceActiveBatteryFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readActiveBatteryFaultsAttribute( + (ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback(), + readPowerSourceActiveBatteryFaultsCommandParams); + readPowerSourceInteractionInfo.put( + "readActiveBatteryFaultsAttribute", + readPowerSourceActiveBatteryFaultsAttributeInteractionInfo); + Map readPowerSourceBatteryChargeStateCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryChargeStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryChargeStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryChargeStateCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryChargeStateAttribute", + readPowerSourceBatteryChargeStateAttributeInteractionInfo); + Map readPowerSourceAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PowerSourceCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), + readPowerSourceAttributeListCommandParams); + readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.put("readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("powerSource", readPowerSourceInteractionInfo); - Map readPowerSourceConfigurationInteractionInfo = 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 - ); - readPowerSourceConfigurationInteractionInfo.put("readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); - Map readPowerSourceConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), - readPowerSourceConfigurationAttributeListCommandParams - ); - readPowerSourceConfigurationInteractionInfo.put("readAttributeListAttribute", readPowerSourceConfigurationAttributeListAttributeInteractionInfo); - Map readPowerSourceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceConfigurationClusterRevisionCommandParams - ); - readPowerSourceConfigurationInteractionInfo.put("readClusterRevisionAttribute", readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo); - Map readPressureMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readPressureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMeasuredValueCommandParams - ); - readPressureMeasurementInteractionInfo.put("readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMinMeasuredValueCommandParams - ); - readPressureMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMaxMeasuredValueCommandParams - ); - readPressureMeasurementInteractionInfo.put("readMaxMeasuredValueAttribute", readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), - readPressureMeasurementAttributeListCommandParams - ); - readPressureMeasurementInteractionInfo.put("readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); - Map readPressureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementClusterRevisionCommandParams - ); - readPressureMeasurementInteractionInfo.put("readClusterRevisionAttribute", readPressureMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("pressureMeasurement", readPressureMeasurementInteractionInfo); - Map readPumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); - Map readPumpConfigurationAndControlMaxPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxPressureAttribute", readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxFlowAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxFlowCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstPressureAttribute", readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxConstPressureAttribute", readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinCompPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinCompPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinCompPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinCompPressureAttribute", readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxCompPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxCompPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxCompPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxCompPressureAttribute", readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstSpeedAttribute", readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxConstSpeedAttribute", readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstFlowAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstFlowCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstFlowAttribute", readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstFlowAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstFlowCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxConstFlowAttribute", readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstTempCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstTempAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstTempCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstTempAttribute", readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstTempCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstTempAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstTempCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.put("readEffectiveControlModeAttribute", readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlCapacityCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readCapacityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlCapacityCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); - Map readPumpConfigurationAndControlSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeRunningHoursAttribute( - ( ChipClusters.PumpConfigurationAndControlCluster.LifetimeRunningHoursAttributeCallback - ) callback - ); - }, + readPowerSourceFeatureMapCommandParams); + readPowerSourceInteractionInfo.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); + readPowerSourceInteractionInfo.put( + "readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("powerSource", readPowerSourceInteractionInfo); + Map readPowerSourceConfigurationInteractionInfo = + 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); + readPowerSourceConfigurationInteractionInfo.put( + "readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); + Map readPowerSourceConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), + readPowerSourceConfigurationAttributeListCommandParams); + readPowerSourceConfigurationInteractionInfo.put( + "readAttributeListAttribute", + readPowerSourceConfigurationAttributeListAttributeInteractionInfo); + Map readPowerSourceConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceConfigurationClusterRevisionCommandParams); + readPowerSourceConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo); + Map readPressureMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readPressureMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMeasuredValueCommandParams); + readPressureMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMinMeasuredValueCommandParams); + readPressureMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMaxMeasuredValueCommandParams); + readPressureMeasurementInteractionInfo.put( + "readMaxMeasuredValueAttribute", + readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), + readPressureMeasurementAttributeListCommandParams); + readPressureMeasurementInteractionInfo.put( + "readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); + Map readPressureMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementClusterRevisionCommandParams); + readPressureMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readPressureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("pressureMeasurement", readPressureMeasurementInteractionInfo); + Map readPumpConfigurationAndControlInteractionInfo = + new LinkedHashMap<>(); + Map readPumpConfigurationAndControlMaxPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxPressureAttribute", + readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxFlowCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstPressureAttribute", + readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxConstPressureAttribute", + readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinCompPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinCompPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinCompPressureAttribute", + readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxCompPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxCompPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxCompPressureAttribute", + readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstSpeedAttribute", + readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxConstSpeedAttribute", + readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstFlowCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstFlowAttribute", + readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstFlowCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxConstFlowAttribute", + readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstTempCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstTempCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstTempAttribute", + readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstTempCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstTempCommandParams); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.put( + "readEffectiveControlModeAttribute", + readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlCapacityCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readCapacityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlCapacityCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); + Map readPumpConfigurationAndControlSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); + Map + readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readLifetimeRunningHoursAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .LifetimeRunningHoursAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlLifetimeRunningHoursCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readLifetimeRunningHoursAttribute", readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); - Map readPumpConfigurationAndControlPowerCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readPowerAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPumpConfigurationAndControlLifetimeRunningHoursCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readLifetimeRunningHoursAttribute", + readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); + Map readPumpConfigurationAndControlPowerCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readPowerAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlPowerCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); - Map readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeEnergyConsumedAttribute( - ( ChipClusters.PumpConfigurationAndControlCluster.LifetimeEnergyConsumedAttributeCallback - ) callback - ); - }, + readPumpConfigurationAndControlPowerCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); + Map + readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readLifetimeEnergyConsumedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .LifetimeEnergyConsumedAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.put("readControlModeAttribute", readPumpConfigurationAndControlControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlAlarmMaskCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAlarmMaskAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlAlarmMaskCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo); - Map readPumpConfigurationAndControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PumpConfigurationAndControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), - readPumpConfigurationAndControlAttributeListCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readAttributeListAttribute", readPumpConfigurationAndControlAttributeListAttributeInteractionInfo); - Map readPumpConfigurationAndControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.put( + "readControlModeAttribute", + readPumpConfigurationAndControlControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlAlarmMaskCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readAlarmMaskAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlAlarmMaskCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo); + Map readPumpConfigurationAndControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), + readPumpConfigurationAndControlAttributeListCommandParams); + readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.put("readClusterRevisionAttribute", readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo); - Map readRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readRelativeHumidityMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMeasuredValueCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readMeasuredValueAttribute", readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMinMeasuredValueCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMaxMeasuredValueCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.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 - ); - readRelativeHumidityMeasurementInteractionInfo.put("readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); - Map readRelativeHumidityMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.RelativeHumidityMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), - readRelativeHumidityMeasurementAttributeListCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readAttributeListAttribute", readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementClusterRevisionCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readClusterRevisionAttribute", readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo); - Map readScenesInteractionInfo = new LinkedHashMap<>(); - Map readScenesSceneCountCommandParams = new LinkedHashMap(); - InteractionInfo readScenesSceneCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readSceneCountAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesSceneCountCommandParams - ); - readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.put("readCurrentGroupAttribute", readScenesCurrentGroupAttributeInteractionInfo); - Map readScenesSceneValidCommandParams = new LinkedHashMap(); - InteractionInfo readScenesSceneValidAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readSceneValidAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readPumpConfigurationAndControlFeatureMapCommandParams); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.put( + "readClusterRevisionAttribute", + readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo); + Map readRelativeHumidityMeasurementInteractionInfo = + new LinkedHashMap<>(); + Map readRelativeHumidityMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMeasuredValueCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", + readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMinMeasuredValueCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMaxMeasuredValueCommandParams); + readRelativeHumidityMeasurementInteractionInfo.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); + readRelativeHumidityMeasurementInteractionInfo.put( + "readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); + Map readRelativeHumidityMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), + readRelativeHumidityMeasurementAttributeListCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementClusterRevisionCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo); + Map readScenesInteractionInfo = new LinkedHashMap<>(); + Map readScenesSceneCountCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesSceneCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readSceneCountAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesSceneCountCommandParams); + readScenesInteractionInfo.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); + readScenesInteractionInfo.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); + readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.put("readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); - Map readScenesAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readScenesAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ScenesCluster.AttributeListAttributeCallback - ) callback - ); - }, + readScenesSceneValidCommandParams); + readScenesInteractionInfo.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); + readScenesInteractionInfo.put( + "readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); + Map readScenesAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ScenesCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedScenesClusterAttributeListAttributeCallback(), - readScenesAttributeListCommandParams - ); - readScenesInteractionInfo.put("readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); - Map readScenesClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesClusterRevisionCommandParams - ); - readScenesInteractionInfo.put("readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("scenes", readScenesInteractionInfo); - Map readSoftwareDiagnosticsInteractionInfo = 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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readThreadMetricsAttribute", readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapFreeCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapFreeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readScenesAttributeListCommandParams); + readScenesInteractionInfo.put( + "readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); + Map readScenesClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesClusterRevisionCommandParams); + readScenesInteractionInfo.put( + "readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("scenes", readScenesInteractionInfo); + Map readSoftwareDiagnosticsInteractionInfo = 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); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readCurrentHeapFreeAttribute", readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapUsedCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapUsedAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSoftwareDiagnosticsCurrentHeapFreeCommandParams); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readCurrentHeapUsedAttribute", readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapHighWatermarkAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSoftwareDiagnosticsCurrentHeapUsedCommandParams); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readCurrentHeapHighWatermarkAttribute", readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); - Map readSoftwareDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), - readSoftwareDiagnosticsAttributeListCommandParams - ); - readSoftwareDiagnosticsInteractionInfo.put("readAttributeListAttribute", readSoftwareDiagnosticsAttributeListAttributeInteractionInfo); - Map readSoftwareDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams); + readSoftwareDiagnosticsInteractionInfo.put( + "readCurrentHeapHighWatermarkAttribute", + readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); + Map readSoftwareDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), + readSoftwareDiagnosticsAttributeListCommandParams); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo); - Map readSwitchInteractionInfo = new LinkedHashMap<>(); - Map readSwitchNumberOfPositionsCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readNumberOfPositionsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchNumberOfPositionsCommandParams - ); - readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.put("readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); - Map readSwitchAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readAttributeListAttribute( - ( ChipClusters.SwitchCluster.AttributeListAttributeCallback - ) callback - ); - }, + readSoftwareDiagnosticsFeatureMapCommandParams); + readSoftwareDiagnosticsInteractionInfo.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); + readSoftwareDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo); + Map readSwitchInteractionInfo = new LinkedHashMap<>(); + Map readSwitchNumberOfPositionsCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readNumberOfPositionsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchNumberOfPositionsCommandParams); + readSwitchInteractionInfo.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); + readSwitchInteractionInfo.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); + readSwitchInteractionInfo.put( + "readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); + Map readSwitchAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.SwitchCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedSwitchClusterAttributeListAttributeCallback(), - readSwitchAttributeListCommandParams - ); - readSwitchInteractionInfo.put("readAttributeListAttribute", readSwitchAttributeListAttributeInteractionInfo); - Map readSwitchFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSwitchAttributeListCommandParams); + readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.put("readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("switch", readSwitchInteractionInfo); - Map readTargetNavigatorInteractionInfo = new LinkedHashMap<>(); - Map readTargetNavigatorTargetNavigatorListCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorTargetNavigatorListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readTargetNavigatorListAttribute( - ( ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback(), - readTargetNavigatorTargetNavigatorListCommandParams - ); - readTargetNavigatorInteractionInfo.put("readTargetNavigatorListAttribute", readTargetNavigatorTargetNavigatorListAttributeInteractionInfo); - Map readTargetNavigatorCurrentNavigatorTargetCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readCurrentNavigatorTargetAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorCurrentNavigatorTargetCommandParams - ); - readTargetNavigatorInteractionInfo.put("readCurrentNavigatorTargetAttribute", readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo); - Map readTargetNavigatorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readAttributeListAttribute( - ( ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), - readTargetNavigatorAttributeListCommandParams - ); - readTargetNavigatorInteractionInfo.put("readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); - Map readTargetNavigatorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorClusterRevisionCommandParams - ); - readTargetNavigatorInteractionInfo.put("readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("targetNavigator", readTargetNavigatorInteractionInfo); - Map readTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readTemperatureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMeasuredValueCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readMeasuredValueAttribute", readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMinMeasuredValueCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMaxMeasuredValueCommandParams - ); - readTemperatureMeasurementInteractionInfo.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 - ); - readTemperatureMeasurementInteractionInfo.put("readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); - Map readTemperatureMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), - readTemperatureMeasurementAttributeListCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readAttributeListAttribute", readTemperatureMeasurementAttributeListAttributeInteractionInfo); - Map readTemperatureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementClusterRevisionCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readClusterRevisionAttribute", readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo); - Map readTestClusterInteractionInfo = new LinkedHashMap<>(); - Map readTestClusterBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readSwitchFeatureMapCommandParams); + readSwitchInteractionInfo.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); + readSwitchInteractionInfo.put( + "readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("switch", readSwitchInteractionInfo); + Map readTargetNavigatorInteractionInfo = new LinkedHashMap<>(); + Map readTargetNavigatorTargetNavigatorListCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorTargetNavigatorListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readTargetNavigatorListAttribute( + (ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback(), + readTargetNavigatorTargetNavigatorListCommandParams); + readTargetNavigatorInteractionInfo.put( + "readTargetNavigatorListAttribute", + readTargetNavigatorTargetNavigatorListAttributeInteractionInfo); + Map readTargetNavigatorCurrentNavigatorTargetCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readCurrentNavigatorTargetAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorCurrentNavigatorTargetCommandParams); + readTargetNavigatorInteractionInfo.put( + "readCurrentNavigatorTargetAttribute", + readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo); + Map readTargetNavigatorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), + readTargetNavigatorAttributeListCommandParams); + readTargetNavigatorInteractionInfo.put( + "readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); + Map readTargetNavigatorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorClusterRevisionCommandParams); + readTargetNavigatorInteractionInfo.put( + "readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("targetNavigator", readTargetNavigatorInteractionInfo); + Map readTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readTemperatureMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMeasuredValueCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", + readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMinMeasuredValueCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMaxMeasuredValueCommandParams); + readTemperatureMeasurementInteractionInfo.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); + readTemperatureMeasurementInteractionInfo.put( + "readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); + Map readTemperatureMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), + readTemperatureMeasurementAttributeListCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readTemperatureMeasurementAttributeListAttributeInteractionInfo); + Map readTemperatureMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementClusterRevisionCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo); + Map readTestClusterInteractionInfo = new LinkedHashMap<>(); + Map readTestClusterBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readBooleanAttribute", readTestClusterBooleanAttributeInteractionInfo); - Map readTestClusterBitmap8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap8Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterBitmap8CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap8Attribute", readTestClusterBitmap8AttributeInteractionInfo); - Map readTestClusterBitmap16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap16Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterBitmap16CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap16Attribute", readTestClusterBitmap16AttributeInteractionInfo); - Map readTestClusterBitmap32CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap32Attribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readBooleanAttribute", readTestClusterBooleanAttributeInteractionInfo); + Map readTestClusterBitmap8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap8Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterBitmap8CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap8Attribute", readTestClusterBitmap8AttributeInteractionInfo); + Map readTestClusterBitmap16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap16Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterBitmap16CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap16Attribute", readTestClusterBitmap16AttributeInteractionInfo); + Map readTestClusterBitmap32CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap32Attribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterBitmap32CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap32Attribute", readTestClusterBitmap32AttributeInteractionInfo); - Map readTestClusterBitmap64CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap64Attribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterBitmap32CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap32Attribute", readTestClusterBitmap32AttributeInteractionInfo); + Map readTestClusterBitmap64CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap64Attribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterBitmap64CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap64Attribute", readTestClusterBitmap64AttributeInteractionInfo); - Map readTestClusterInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt8uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readInt8uAttribute", readTestClusterInt8uAttributeInteractionInfo); - Map readTestClusterInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt16uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); - Map readTestClusterInt24uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt24uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterBitmap64CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap64Attribute", readTestClusterBitmap64AttributeInteractionInfo); + Map readTestClusterInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt8uAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readInt8uAttribute", readTestClusterInt8uAttributeInteractionInfo); + Map readTestClusterInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt16uAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); + Map readTestClusterInt24uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt24uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt24uCommandParams - ); - readTestClusterInteractionInfo.put("readInt24uAttribute", readTestClusterInt24uAttributeInteractionInfo); - Map readTestClusterInt32uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt32uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt24uCommandParams); + readTestClusterInteractionInfo.put( + "readInt24uAttribute", readTestClusterInt24uAttributeInteractionInfo); + Map readTestClusterInt32uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt32uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt32uCommandParams - ); - readTestClusterInteractionInfo.put("readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); - Map readTestClusterInt40uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt40uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt32uCommandParams); + readTestClusterInteractionInfo.put( + "readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); + Map readTestClusterInt40uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt40uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt40uCommandParams - ); - readTestClusterInteractionInfo.put("readInt40uAttribute", readTestClusterInt40uAttributeInteractionInfo); - Map readTestClusterInt48uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt48uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt40uCommandParams); + readTestClusterInteractionInfo.put( + "readInt40uAttribute", readTestClusterInt40uAttributeInteractionInfo); + Map readTestClusterInt48uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt48uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt48uCommandParams - ); - readTestClusterInteractionInfo.put("readInt48uAttribute", readTestClusterInt48uAttributeInteractionInfo); - Map readTestClusterInt56uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt56uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt48uCommandParams); + readTestClusterInteractionInfo.put( + "readInt48uAttribute", readTestClusterInt48uAttributeInteractionInfo); + Map readTestClusterInt56uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt56uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt56uCommandParams - ); - readTestClusterInteractionInfo.put("readInt56uAttribute", readTestClusterInt56uAttributeInteractionInfo); - Map readTestClusterInt64uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt64uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt56uCommandParams); + readTestClusterInteractionInfo.put( + "readInt56uAttribute", readTestClusterInt56uAttributeInteractionInfo); + Map readTestClusterInt64uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt64uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt64uCommandParams - ); - readTestClusterInteractionInfo.put("readInt64uAttribute", readTestClusterInt64uAttributeInteractionInfo); - Map readTestClusterInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt8sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readInt8sAttribute", readTestClusterInt8sAttributeInteractionInfo); - Map readTestClusterInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt16sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); - Map readTestClusterInt24sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt24sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt64uCommandParams); + readTestClusterInteractionInfo.put( + "readInt64uAttribute", readTestClusterInt64uAttributeInteractionInfo); + Map readTestClusterInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt8sAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readInt8sAttribute", readTestClusterInt8sAttributeInteractionInfo); + Map readTestClusterInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt16sAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); + Map readTestClusterInt24sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt24sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt24sCommandParams - ); - readTestClusterInteractionInfo.put("readInt24sAttribute", readTestClusterInt24sAttributeInteractionInfo); - Map readTestClusterInt32sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt32sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt24sCommandParams); + readTestClusterInteractionInfo.put( + "readInt24sAttribute", readTestClusterInt24sAttributeInteractionInfo); + Map readTestClusterInt32sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt32sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt32sCommandParams - ); - readTestClusterInteractionInfo.put("readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); - Map readTestClusterInt40sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt40sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt32sCommandParams); + readTestClusterInteractionInfo.put( + "readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); + Map readTestClusterInt40sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt40sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt40sCommandParams - ); - readTestClusterInteractionInfo.put("readInt40sAttribute", readTestClusterInt40sAttributeInteractionInfo); - Map readTestClusterInt48sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt48sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt40sCommandParams); + readTestClusterInteractionInfo.put( + "readInt40sAttribute", readTestClusterInt40sAttributeInteractionInfo); + Map readTestClusterInt48sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt48sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt48sCommandParams - ); - readTestClusterInteractionInfo.put("readInt48sAttribute", readTestClusterInt48sAttributeInteractionInfo); - Map readTestClusterInt56sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt56sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt48sCommandParams); + readTestClusterInteractionInfo.put( + "readInt48sAttribute", readTestClusterInt48sAttributeInteractionInfo); + Map readTestClusterInt56sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt56sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt56sCommandParams - ); - readTestClusterInteractionInfo.put("readInt56sAttribute", readTestClusterInt56sAttributeInteractionInfo); - Map readTestClusterInt64sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt64sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt56sCommandParams); + readTestClusterInteractionInfo.put( + "readInt56sAttribute", readTestClusterInt56sAttributeInteractionInfo); + Map readTestClusterInt64sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt64sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt64sCommandParams - ); - readTestClusterInteractionInfo.put("readInt64sAttribute", readTestClusterInt64sAttributeInteractionInfo); - Map readTestClusterEnum8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEnum8Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnum8CommandParams - ); - readTestClusterInteractionInfo.put("readEnum8Attribute", readTestClusterEnum8AttributeInteractionInfo); - Map readTestClusterEnum16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEnum16Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnum16CommandParams - ); - readTestClusterInteractionInfo.put("readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); - Map readTestClusterFloatSingleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readFloatSingleAttribute( - ( - ChipClusters.FloatAttributeCallback -) callback - ); - }, + readTestClusterInt64sCommandParams); + readTestClusterInteractionInfo.put( + "readInt64sAttribute", readTestClusterInt64sAttributeInteractionInfo); + Map readTestClusterEnum8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEnum8Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnum8CommandParams); + readTestClusterInteractionInfo.put( + "readEnum8Attribute", readTestClusterEnum8AttributeInteractionInfo); + Map readTestClusterEnum16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEnum16Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnum16CommandParams); + readTestClusterInteractionInfo.put( + "readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); + Map readTestClusterFloatSingleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readFloatSingleAttribute((ChipClusters.FloatAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readTestClusterFloatSingleCommandParams - ); - readTestClusterInteractionInfo.put("readFloatSingleAttribute", readTestClusterFloatSingleAttributeInteractionInfo); - Map readTestClusterFloatDoubleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readFloatDoubleAttribute( - ( - ChipClusters.DoubleAttributeCallback -) callback - ); - }, + readTestClusterFloatSingleCommandParams); + readTestClusterInteractionInfo.put( + "readFloatSingleAttribute", readTestClusterFloatSingleAttributeInteractionInfo); + Map readTestClusterFloatDoubleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readFloatDoubleAttribute((ChipClusters.DoubleAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readTestClusterFloatDoubleCommandParams - ); - readTestClusterInteractionInfo.put("readFloatDoubleAttribute", readTestClusterFloatDoubleAttributeInteractionInfo); - Map readTestClusterOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readOctetStringAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readTestClusterFloatDoubleCommandParams); + readTestClusterInteractionInfo.put( + "readFloatDoubleAttribute", readTestClusterFloatDoubleAttributeInteractionInfo); + Map readTestClusterOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readOctetStringAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readOctetStringAttribute", readTestClusterOctetStringAttributeInteractionInfo); - Map readTestClusterListInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListInt8uAttribute( - ( ChipClusters.TestClusterCluster.ListInt8uAttributeCallback - ) callback - ); - }, + readTestClusterOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readOctetStringAttribute", readTestClusterOctetStringAttributeInteractionInfo); + Map readTestClusterListInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListInt8uAttribute( + (ChipClusters.TestClusterCluster.ListInt8uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedTestClusterClusterListInt8uAttributeCallback(), - readTestClusterListInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readListInt8uAttribute", readTestClusterListInt8uAttributeInteractionInfo); - Map readTestClusterListOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListOctetStringAttribute( - ( ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListOctetStringAttributeCallback(), - readTestClusterListOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readListOctetStringAttribute", readTestClusterListOctetStringAttributeInteractionInfo); - Map readTestClusterListStructOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListStructOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListStructOctetStringAttribute( - ( ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListStructOctetStringAttributeCallback(), - readTestClusterListStructOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readListStructOctetStringAttribute", readTestClusterListStructOctetStringAttributeInteractionInfo); - Map readTestClusterLongOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readLongOctetStringAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readTestClusterListInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readListInt8uAttribute", readTestClusterListInt8uAttributeInteractionInfo); + Map readTestClusterListOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListOctetStringAttribute( + (ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListOctetStringAttributeCallback(), + readTestClusterListOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readListOctetStringAttribute", readTestClusterListOctetStringAttributeInteractionInfo); + Map readTestClusterListStructOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListStructOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListStructOctetStringAttribute( + (ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListStructOctetStringAttributeCallback(), + readTestClusterListStructOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readListStructOctetStringAttribute", + readTestClusterListStructOctetStringAttributeInteractionInfo); + Map readTestClusterLongOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readLongOctetStringAttribute( + (ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterLongOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeInteractionInfo); - Map readTestClusterCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readCharStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readTestClusterLongOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeInteractionInfo); + Map readTestClusterCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterCharStringCommandParams - ); - readTestClusterInteractionInfo.put("readCharStringAttribute", readTestClusterCharStringAttributeInteractionInfo); - Map readTestClusterLongCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterLongCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readLongCharStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readTestClusterCharStringCommandParams); + readTestClusterInteractionInfo.put( + "readCharStringAttribute", readTestClusterCharStringAttributeInteractionInfo); + Map readTestClusterLongCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterLongCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readLongCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterLongCharStringCommandParams - ); - readTestClusterInteractionInfo.put("readLongCharStringAttribute", readTestClusterLongCharStringAttributeInteractionInfo); - Map readTestClusterEpochUsCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEpochUsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEpochUsAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterLongCharStringCommandParams); + readTestClusterInteractionInfo.put( + "readLongCharStringAttribute", readTestClusterLongCharStringAttributeInteractionInfo); + Map readTestClusterEpochUsCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEpochUsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEpochUsAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterEpochUsCommandParams - ); - readTestClusterInteractionInfo.put("readEpochUsAttribute", readTestClusterEpochUsAttributeInteractionInfo); - Map readTestClusterEpochSCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEpochSAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEpochSAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterEpochUsCommandParams); + readTestClusterInteractionInfo.put( + "readEpochUsAttribute", readTestClusterEpochUsAttributeInteractionInfo); + Map readTestClusterEpochSCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEpochSAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEpochSAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterEpochSCommandParams - ); - readTestClusterInteractionInfo.put("readEpochSAttribute", readTestClusterEpochSAttributeInteractionInfo); - Map readTestClusterVendorIdCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readVendorIdAttribute( - ( ChipClusters.TestClusterCluster.VendorIdAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterVendorIdCommandParams - ); - readTestClusterInteractionInfo.put("readVendorIdAttribute", readTestClusterVendorIdAttributeInteractionInfo); - Map readTestClusterListNullablesAndOptionalsStructCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListNullablesAndOptionalsStructAttribute( - ( ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback(), - readTestClusterListNullablesAndOptionalsStructCommandParams - ); - readTestClusterInteractionInfo.put("readListNullablesAndOptionalsStructAttribute", readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); - Map readTestClusterEnumAttrCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEnumAttrAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnumAttrCommandParams - ); - readTestClusterInteractionInfo.put("readEnumAttrAttribute", readTestClusterEnumAttrAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt8uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt8uAttribute", readTestClusterRangeRestrictedInt8uAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt8sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt8sAttribute", readTestClusterRangeRestrictedInt8sAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt16uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt16uAttribute", readTestClusterRangeRestrictedInt16uAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt16sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt16sAttribute", readTestClusterRangeRestrictedInt16sAttributeInteractionInfo); - Map readTestClusterListLongOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListLongOctetStringAttribute( - ( ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListLongOctetStringAttributeCallback(), - readTestClusterListLongOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readListLongOctetStringAttribute", readTestClusterListLongOctetStringAttributeInteractionInfo); - Map readTestClusterTimedWriteBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readTimedWriteBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterEpochSCommandParams); + readTestClusterInteractionInfo.put( + "readEpochSAttribute", readTestClusterEpochSAttributeInteractionInfo); + Map readTestClusterVendorIdCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readVendorIdAttribute( + (ChipClusters.TestClusterCluster.VendorIdAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterVendorIdCommandParams); + readTestClusterInteractionInfo.put( + "readVendorIdAttribute", readTestClusterVendorIdAttributeInteractionInfo); + Map readTestClusterListNullablesAndOptionalsStructCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListNullablesAndOptionalsStructAttribute( + (ChipClusters.TestClusterCluster + .ListNullablesAndOptionalsStructAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback(), + readTestClusterListNullablesAndOptionalsStructCommandParams); + readTestClusterInteractionInfo.put( + "readListNullablesAndOptionalsStructAttribute", + readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); + Map readTestClusterEnumAttrCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEnumAttrAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnumAttrCommandParams); + readTestClusterInteractionInfo.put( + "readEnumAttrAttribute", readTestClusterEnumAttrAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt8uAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt8uAttribute", + readTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt8sAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt8sAttribute", + readTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt16uAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt16uAttribute", + readTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt16sAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt16sAttribute", + readTestClusterRangeRestrictedInt16sAttributeInteractionInfo); + Map readTestClusterListLongOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListLongOctetStringAttribute( + (ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListLongOctetStringAttributeCallback(), + readTestClusterListLongOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readListLongOctetStringAttribute", + readTestClusterListLongOctetStringAttributeInteractionInfo); + Map readTestClusterTimedWriteBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterTimedWriteBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readTimedWriteBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterTimedWriteBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readTimedWriteBooleanAttribute", readTestClusterTimedWriteBooleanAttributeInteractionInfo); - Map readTestClusterGeneralErrorBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readGeneralErrorBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterTimedWriteBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readTimedWriteBooleanAttribute", readTestClusterTimedWriteBooleanAttributeInteractionInfo); + Map readTestClusterGeneralErrorBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterGeneralErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readGeneralErrorBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterGeneralErrorBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readGeneralErrorBooleanAttribute", readTestClusterGeneralErrorBooleanAttributeInteractionInfo); - Map readTestClusterClusterErrorBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readClusterErrorBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterGeneralErrorBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readGeneralErrorBooleanAttribute", + readTestClusterGeneralErrorBooleanAttributeInteractionInfo); + Map readTestClusterClusterErrorBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterClusterErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readClusterErrorBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterClusterErrorBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readClusterErrorBooleanAttribute", readTestClusterClusterErrorBooleanAttributeInteractionInfo); - Map readTestClusterUnsupportedCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readUnsupportedAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterClusterErrorBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readClusterErrorBooleanAttribute", + readTestClusterClusterErrorBooleanAttributeInteractionInfo); + Map readTestClusterUnsupportedCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readUnsupportedAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterUnsupportedCommandParams - ); - readTestClusterInteractionInfo.put("readUnsupportedAttribute", readTestClusterUnsupportedAttributeInteractionInfo); - Map readTestClusterNullableBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBooleanAttribute( - ( ChipClusters.TestClusterCluster.NullableBooleanAttributeCallback - ) callback - ); - }, + readTestClusterUnsupportedCommandParams); + readTestClusterInteractionInfo.put( + "readUnsupportedAttribute", readTestClusterUnsupportedAttributeInteractionInfo); + Map readTestClusterNullableBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBooleanAttribute( + (ChipClusters.TestClusterCluster.NullableBooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterNullableBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeInteractionInfo); - Map readTestClusterNullableBitmap8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap8Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap8AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableBitmap8CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeInteractionInfo); - Map readTestClusterNullableBitmap16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap16Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap16AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableBitmap16CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeInteractionInfo); - Map readTestClusterNullableBitmap32CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap32Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap32AttributeCallback - ) callback - ); - }, + readTestClusterNullableBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeInteractionInfo); + Map readTestClusterNullableBitmap8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap8Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap8AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableBitmap8CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeInteractionInfo); + Map readTestClusterNullableBitmap16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap16Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap16AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableBitmap16CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeInteractionInfo); + Map readTestClusterNullableBitmap32CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap32Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap32AttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableBitmap32CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeInteractionInfo); - Map readTestClusterNullableBitmap64CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap64Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap64AttributeCallback - ) callback - ); - }, + readTestClusterNullableBitmap32CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeInteractionInfo); + Map readTestClusterNullableBitmap64CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap64Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap64AttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableBitmap64CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeInteractionInfo); - Map readTestClusterNullableInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt8uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt8uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeInteractionInfo); - Map readTestClusterNullableInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt16uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt16uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); - Map readTestClusterNullableInt24uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt24uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt24uAttributeCallback - ) callback - ); - }, + readTestClusterNullableBitmap64CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeInteractionInfo); + Map readTestClusterNullableInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt8uAttribute( + (ChipClusters.TestClusterCluster.NullableInt8uAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeInteractionInfo); + Map readTestClusterNullableInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt16uAttribute( + (ChipClusters.TestClusterCluster.NullableInt16uAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); + Map readTestClusterNullableInt24uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt24uAttribute( + (ChipClusters.TestClusterCluster.NullableInt24uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt24uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt24uAttribute", readTestClusterNullableInt24uAttributeInteractionInfo); - Map readTestClusterNullableInt32uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt32uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt32uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt24uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt24uAttribute", readTestClusterNullableInt24uAttributeInteractionInfo); + Map readTestClusterNullableInt32uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt32uAttribute( + (ChipClusters.TestClusterCluster.NullableInt32uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt32uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); - Map readTestClusterNullableInt40uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt40uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt40uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt32uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); + Map readTestClusterNullableInt40uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt40uAttribute( + (ChipClusters.TestClusterCluster.NullableInt40uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt40uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt40uAttribute", readTestClusterNullableInt40uAttributeInteractionInfo); - Map readTestClusterNullableInt48uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt48uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt48uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt40uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt40uAttribute", readTestClusterNullableInt40uAttributeInteractionInfo); + Map readTestClusterNullableInt48uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt48uAttribute( + (ChipClusters.TestClusterCluster.NullableInt48uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt48uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt48uAttribute", readTestClusterNullableInt48uAttributeInteractionInfo); - Map readTestClusterNullableInt56uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt56uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt56uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt48uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt48uAttribute", readTestClusterNullableInt48uAttributeInteractionInfo); + Map readTestClusterNullableInt56uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt56uAttribute( + (ChipClusters.TestClusterCluster.NullableInt56uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt56uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt56uAttribute", readTestClusterNullableInt56uAttributeInteractionInfo); - Map readTestClusterNullableInt64uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt64uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt64uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt56uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt56uAttribute", readTestClusterNullableInt56uAttributeInteractionInfo); + Map readTestClusterNullableInt64uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt64uAttribute( + (ChipClusters.TestClusterCluster.NullableInt64uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt64uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeInteractionInfo); - Map readTestClusterNullableInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt8sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt8sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeInteractionInfo); - Map readTestClusterNullableInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt16sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt16sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); - Map readTestClusterNullableInt24sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt24sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt24sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt64uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeInteractionInfo); + Map readTestClusterNullableInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt8sAttribute( + (ChipClusters.TestClusterCluster.NullableInt8sAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeInteractionInfo); + Map readTestClusterNullableInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt16sAttribute( + (ChipClusters.TestClusterCluster.NullableInt16sAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); + Map readTestClusterNullableInt24sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt24sAttribute( + (ChipClusters.TestClusterCluster.NullableInt24sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt24sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt24sAttribute", readTestClusterNullableInt24sAttributeInteractionInfo); - Map readTestClusterNullableInt32sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt32sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt32sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt24sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt24sAttribute", readTestClusterNullableInt24sAttributeInteractionInfo); + Map readTestClusterNullableInt32sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt32sAttribute( + (ChipClusters.TestClusterCluster.NullableInt32sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt32sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); - Map readTestClusterNullableInt40sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt40sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt40sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt32sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); + Map readTestClusterNullableInt40sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt40sAttribute( + (ChipClusters.TestClusterCluster.NullableInt40sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt40sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt40sAttribute", readTestClusterNullableInt40sAttributeInteractionInfo); - Map readTestClusterNullableInt48sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt48sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt48sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt40sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt40sAttribute", readTestClusterNullableInt40sAttributeInteractionInfo); + Map readTestClusterNullableInt48sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt48sAttribute( + (ChipClusters.TestClusterCluster.NullableInt48sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt48sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt48sAttribute", readTestClusterNullableInt48sAttributeInteractionInfo); - Map readTestClusterNullableInt56sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt56sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt56sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt48sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt48sAttribute", readTestClusterNullableInt48sAttributeInteractionInfo); + Map readTestClusterNullableInt56sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt56sAttribute( + (ChipClusters.TestClusterCluster.NullableInt56sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt56sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt56sAttribute", readTestClusterNullableInt56sAttributeInteractionInfo); - Map readTestClusterNullableInt64sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt64sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt64sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt56sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt56sAttribute", readTestClusterNullableInt56sAttributeInteractionInfo); + Map readTestClusterNullableInt64sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt64sAttribute( + (ChipClusters.TestClusterCluster.NullableInt64sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt64sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeInteractionInfo); - Map readTestClusterNullableEnum8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableEnum8Attribute( - ( ChipClusters.TestClusterCluster.NullableEnum8AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnum8CommandParams - ); - readTestClusterInteractionInfo.put("readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeInteractionInfo); - Map readTestClusterNullableEnum16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableEnum16Attribute( - ( ChipClusters.TestClusterCluster.NullableEnum16AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnum16CommandParams - ); - readTestClusterInteractionInfo.put("readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); - Map readTestClusterNullableFloatSingleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableFloatSingleAttribute( - ( ChipClusters.TestClusterCluster.NullableFloatSingleAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt64sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeInteractionInfo); + Map readTestClusterNullableEnum8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableEnum8Attribute( + (ChipClusters.TestClusterCluster.NullableEnum8AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnum8CommandParams); + readTestClusterInteractionInfo.put( + "readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeInteractionInfo); + Map readTestClusterNullableEnum16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableEnum16Attribute( + (ChipClusters.TestClusterCluster.NullableEnum16AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnum16CommandParams); + readTestClusterInteractionInfo.put( + "readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); + Map readTestClusterNullableFloatSingleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableFloatSingleAttribute( + (ChipClusters.TestClusterCluster.NullableFloatSingleAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readTestClusterNullableFloatSingleCommandParams - ); - readTestClusterInteractionInfo.put("readNullableFloatSingleAttribute", readTestClusterNullableFloatSingleAttributeInteractionInfo); - Map readTestClusterNullableFloatDoubleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableFloatDoubleAttribute( - ( ChipClusters.TestClusterCluster.NullableFloatDoubleAttributeCallback - ) callback - ); - }, + readTestClusterNullableFloatSingleCommandParams); + readTestClusterInteractionInfo.put( + "readNullableFloatSingleAttribute", + readTestClusterNullableFloatSingleAttributeInteractionInfo); + Map readTestClusterNullableFloatDoubleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableFloatDoubleAttribute( + (ChipClusters.TestClusterCluster.NullableFloatDoubleAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readTestClusterNullableFloatDoubleCommandParams - ); - readTestClusterInteractionInfo.put("readNullableFloatDoubleAttribute", readTestClusterNullableFloatDoubleAttributeInteractionInfo); - Map readTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableOctetStringAttribute( - ( ChipClusters.TestClusterCluster.NullableOctetStringAttributeCallback - ) callback - ); - }, + readTestClusterNullableFloatDoubleCommandParams); + readTestClusterInteractionInfo.put( + "readNullableFloatDoubleAttribute", + readTestClusterNullableFloatDoubleAttributeInteractionInfo); + Map readTestClusterNullableOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableOctetStringAttribute( + (ChipClusters.TestClusterCluster.NullableOctetStringAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterNullableOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readNullableOctetStringAttribute", readTestClusterNullableOctetStringAttributeInteractionInfo); - Map readTestClusterNullableCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableCharStringAttribute( - ( ChipClusters.TestClusterCluster.NullableCharStringAttributeCallback - ) callback - ); - }, + readTestClusterNullableOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readNullableOctetStringAttribute", + readTestClusterNullableOctetStringAttributeInteractionInfo); + Map readTestClusterNullableCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableCharStringAttribute( + (ChipClusters.TestClusterCluster.NullableCharStringAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterNullableCharStringCommandParams - ); - readTestClusterInteractionInfo.put("readNullableCharStringAttribute", readTestClusterNullableCharStringAttributeInteractionInfo); - Map readTestClusterNullableEnumAttrCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableEnumAttrAttribute( - ( ChipClusters.TestClusterCluster.NullableEnumAttrAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnumAttrCommandParams - ); - readTestClusterInteractionInfo.put("readNullableEnumAttrAttribute", readTestClusterNullableEnumAttrAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt8uAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt8uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt8uAttribute", readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt8sAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt8sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt8sAttribute", readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt16uAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt16uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt16uAttribute", readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt16sAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt16sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt16sAttribute", readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); - Map readTestClusterAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readAttributeListAttribute( - ( ChipClusters.TestClusterCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterAttributeListAttributeCallback(), - readTestClusterAttributeListCommandParams - ); - readTestClusterInteractionInfo.put("readAttributeListAttribute", readTestClusterAttributeListAttributeInteractionInfo); - Map readTestClusterClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterClusterRevisionCommandParams - ); - readTestClusterInteractionInfo.put("readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("testCluster", readTestClusterInteractionInfo); - Map readThermostatInteractionInfo = new LinkedHashMap<>(); - Map readThermostatLocalTemperatureCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readLocalTemperatureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatLocalTemperatureCommandParams - ); - readThermostatInteractionInfo.put("readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); - Map readThermostatAbsMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAbsMinHeatSetpointLimitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMinHeatSetpointLimitCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readAbsMaxCoolSetpointLimitAttribute", readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readOccupiedCoolingSetpointAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatOccupiedCoolingSetpointCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readOccupiedHeatingSetpointAttribute", readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); - Map readThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readMinHeatSetpointLimitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMinHeatSetpointLimitCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readMinSetpointDeadBandAttribute", readThermostatMinSetpointDeadBandAttributeInteractionInfo); - Map readThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readControlSequenceOfOperationAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatControlSequenceOfOperationCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); - Map readThermostatStartOfWeekCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readStartOfWeekAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatStartOfWeekCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readNumberOfDailyTransitionsAttribute", readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); - Map readThermostatAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ThermostatCluster.AttributeListAttributeCallback - ) callback - ); - }, + readTestClusterNullableCharStringCommandParams); + readTestClusterInteractionInfo.put( + "readNullableCharStringAttribute", + readTestClusterNullableCharStringAttributeInteractionInfo); + Map readTestClusterNullableEnumAttrCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableEnumAttrAttribute( + (ChipClusters.TestClusterCluster.NullableEnumAttrAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnumAttrCommandParams); + readTestClusterInteractionInfo.put( + "readNullableEnumAttrAttribute", readTestClusterNullableEnumAttrAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt8uAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt8uAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt8uAttribute", + readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt8sAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt8sAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt8sAttribute", + readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt16uAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt16uAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt16uAttribute", + readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt16sAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt16sAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt16sAttribute", + readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); + Map readTestClusterAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TestClusterCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedTestClusterClusterAttributeListAttributeCallback(), + readTestClusterAttributeListCommandParams); + readTestClusterInteractionInfo.put( + "readAttributeListAttribute", readTestClusterAttributeListAttributeInteractionInfo); + Map readTestClusterClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterClusterRevisionCommandParams); + readTestClusterInteractionInfo.put( + "readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("testCluster", readTestClusterInteractionInfo); + Map readThermostatInteractionInfo = new LinkedHashMap<>(); + Map readThermostatLocalTemperatureCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readLocalTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatLocalTemperatureCommandParams); + readThermostatInteractionInfo.put( + "readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); + Map readThermostatAbsMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAbsMinHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMinHeatSetpointLimitCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readAbsMaxCoolSetpointLimitAttribute", + readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatOccupiedCoolingSetpointCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readOccupiedCoolingSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatOccupiedCoolingSetpointCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readOccupiedHeatingSetpointAttribute", + readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); + Map readThermostatMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readMinHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMinHeatSetpointLimitCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readMinSetpointDeadBandAttribute", + readThermostatMinSetpointDeadBandAttributeInteractionInfo); + Map readThermostatControlSequenceOfOperationCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readControlSequenceOfOperationAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatControlSequenceOfOperationCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); + Map readThermostatStartOfWeekCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readStartOfWeekAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatStartOfWeekCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readNumberOfDailyTransitionsAttribute", + readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); + Map readThermostatAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThermostatCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedThermostatClusterAttributeListAttributeCallback(), - readThermostatAttributeListCommandParams - ); - readThermostatInteractionInfo.put("readAttributeListAttribute", readThermostatAttributeListAttributeInteractionInfo); - Map readThermostatFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThermostatAttributeListCommandParams); + readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("thermostat", readThermostatInteractionInfo); - Map readThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); - Map readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readTemperatureDisplayModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams - ); - readThermostatUserInterfaceConfigurationInteractionInfo.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 - ); - readThermostatUserInterfaceConfigurationInteractionInfo.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 - ); - readThermostatUserInterfaceConfigurationInteractionInfo.put("readScheduleProgrammingVisibilityAttribute", readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ThermostatUserInterfaceConfigurationCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), - readThermostatUserInterfaceConfigurationAttributeListCommandParams - ); - readThermostatUserInterfaceConfigurationInteractionInfo.put("readAttributeListAttribute", readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationClusterRevisionCommandParams - ); - readThermostatUserInterfaceConfigurationInteractionInfo.put("readClusterRevisionAttribute", readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("thermostatUserInterfaceConfiguration", readThermostatUserInterfaceConfigurationInteractionInfo); - Map readThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - Map readThreadNetworkDiagnosticsChannelCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsChannelCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRoutingRoleAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsRoutingRoleCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRoutingRoleAttribute", readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNetworkNameCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNetworkNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readThermostatFeatureMapCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("thermostat", readThermostatInteractionInfo); + Map readThermostatUserInterfaceConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = + new LinkedHashMap(); + InteractionInfo + readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readTemperatureDisplayModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams); + readThermostatUserInterfaceConfigurationInteractionInfo.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); + readThermostatUserInterfaceConfigurationInteractionInfo.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); + readThermostatUserInterfaceConfigurationInteractionInfo.put( + "readScheduleProgrammingVisibilityAttribute", + readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThermostatUserInterfaceConfigurationCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), + readThermostatUserInterfaceConfigurationAttributeListCommandParams); + readThermostatUserInterfaceConfigurationInteractionInfo.put( + "readAttributeListAttribute", + readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo + readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams); + readThermostatUserInterfaceConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "thermostatUserInterfaceConfiguration", + readThermostatUserInterfaceConfigurationInteractionInfo); + Map readThreadNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + Map readThreadNetworkDiagnosticsChannelCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readChannelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsChannelCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRoutingRoleAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsRoutingRoleCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRoutingRoleAttribute", + readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNetworkNameCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readNetworkNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readThreadNetworkDiagnosticsNetworkNameCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readNetworkNameAttribute", readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPanIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPanIdAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsPanIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readExtendedPanIdAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsNetworkNameCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readNetworkNameAttribute", + readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPanIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPanIdAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsPanIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readExtendedPanIdAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsExtendedPanIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readExtendedPanIdAttribute", readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readMeshLocalPrefixAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsExtendedPanIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readExtendedPanIdAttribute", + readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readMeshLocalPrefixAttribute( + (ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readMeshLocalPrefixAttribute", readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNeighborTableListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNeighborTableListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback(), - readThreadNetworkDiagnosticsNeighborTableListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readNeighborTableListAttribute", readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRouteTableListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRouteTableListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback(), - readThreadNetworkDiagnosticsRouteTableListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRouteTableListAttribute", readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPartitionIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPartitionIdAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsOverrunCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readOverrunCountAttribute", + readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNeighborTableListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readNeighborTableListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .NeighborTableListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback(), + readThreadNetworkDiagnosticsNeighborTableListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readNeighborTableListAttribute", + readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRouteTableListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRouteTableListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback(), + readThreadNetworkDiagnosticsRouteTableListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRouteTableListAttribute", + readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPartitionIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPartitionIdAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsPartitionIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readPartitionIdAttribute", readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsWeightingCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readWeightingAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsWeightingCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDataVersionCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDataVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsDataVersionCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readDataVersionAttribute", readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readStableDataVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsStableDataVersionCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readStableDataVersionAttribute", readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readLeaderRouterIdAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsLeaderRouterIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readParentChangeCountAttribute", readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxTotalCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxTotalCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsPartitionIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readPartitionIdAttribute", + readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsWeightingCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readWeightingAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsWeightingCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDataVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsDataVersionCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readDataVersionAttribute", + readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readStableDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsStableDataVersionCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readStableDataVersionAttribute", + readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readLeaderRouterIdAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsLeaderRouterIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxTotalCountAttribute", readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxUnicastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxUnicastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxTotalCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxUnicastCountAttribute", readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBroadcastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBroadcastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxUnicastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxBroadcastCountAttribute", readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxAckRequestedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxBroadcastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxAckRequestedCountAttribute", readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxAckedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxAckedCountAttribute", readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxNoAckRequestedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxAckedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxNoAckRequestedCountAttribute", readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDataCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxDataCountAttribute", readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataPollCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDataPollCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxDataCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxDataPollCountAttribute", readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBeaconCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBeaconCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxDataPollCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxBeaconCountAttribute", readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBeaconRequestCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxBeaconCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxOtherCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxOtherCountAttribute", readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxRetryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxRetryCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxOtherCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxRetryCountAttribute", readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDirectMaxRetryExpiryCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxRetryCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxIndirectMaxRetryExpiryCountAttribute", + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrCcaCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxDirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxIndirectMaxRetryExpiryCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxErrCcaCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxErrCcaCountAttribute", + readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrAbortCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxIndirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrCcaCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxErrAbortCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxErrAbortCountAttribute", + readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrBusyChannelCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrCcaCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrCcaCountAttribute", readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrAbortCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxErrBusyChannelCountAttribute", + readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrAbortCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrAbortCountAttribute", readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrBusyChannelCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxTotalCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxTotalCountAttribute", + readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrBusyChannelCountAttribute", readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxTotalCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxUnicastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxUnicastCountAttribute", + readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxTotalCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxTotalCountAttribute", readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxUnicastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxBroadcastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxBroadcastCountAttribute", + readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxUnicastCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxUnicastCountAttribute", readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBroadcastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDataCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDataCountAttribute", + readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBroadcastCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxBroadcastCountAttribute", readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDataPollCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDataPollCountAttribute", + readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDataCountAttribute", readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataPollCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxBeaconCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxBeaconCountAttribute", + readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataPollCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDataPollCountAttribute", readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxBeaconRequestCountAttribute", + readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxBeaconCountAttribute", readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconRequestCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxOtherCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxOtherCountAttribute", + readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxAddressFilteredCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxOtherCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxAddressFilteredCountAttribute", + readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDestAddrFilteredCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxOtherCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxOtherCountAttribute", readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxAddressFilteredCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDestAddrFilteredCountAttribute", + readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDuplicatedCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxAddressFilteredCountAttribute", readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDestAddrFilteredCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDuplicatedCountAttribute", + readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrNoFrameCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDestAddrFilteredCountAttribute", readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDuplicatedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrNoFrameCountAttribute", + readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrUnknownNeighborCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDuplicatedCountAttribute", readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrNoFrameCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrUnknownNeighborCountAttribute", + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrInvalidSrcAddrCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrNoFrameCountAttribute", readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrUnknownNeighborCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrInvalidSrcAddrCountAttribute", + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrSecCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrUnknownNeighborCountAttribute", readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrInvalidSrcAddrCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrSecCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrSecCountAttribute", + readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrFcsCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrInvalidSrcAddrCountAttribute", readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrSecCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrFcsCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrFcsCountAttribute", + readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrSecCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrSecCountAttribute", readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrFcsCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrOtherCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrOtherCountAttribute", + readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readActiveTimestampAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrFcsCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrFcsCountAttribute", readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrOtherCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsActiveTimestampCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readActiveTimestampAttribute", + readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPendingTimestampAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrOtherCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrOtherCountAttribute", readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveTimestampAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsPendingTimestampCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readPendingTimestampAttribute", + readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDelayCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readDelayAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsActiveTimestampCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readActiveTimestampAttribute", readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPendingTimestampAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsPendingTimestampCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readPendingTimestampAttribute", readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDelayCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDelayAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsDelayCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsSecurityPolicyCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readSecurityPolicyAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback(), - readThreadNetworkDiagnosticsSecurityPolicyCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readSecurityPolicyAttribute", readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsChannelMaskCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelMaskAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsDelayCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsSecurityPolicyCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readSecurityPolicyAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback(), + readThreadNetworkDiagnosticsSecurityPolicyCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readSecurityPolicyAttribute", + readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsChannelMaskCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readChannelMaskAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readThreadNetworkDiagnosticsChannelMaskCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readChannelMaskAttribute", readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readOperationalDatasetComponentsAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.OperationalDatasetComponentsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback(), - readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readOperationalDatasetComponentsAttribute", readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveNetworkFaultsListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), - readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readActiveNetworkFaultsListAttribute", readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readThreadNetworkDiagnosticsAttributeListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readAttributeListAttribute", readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsChannelMaskCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readChannelMaskAttribute", + readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams = + new LinkedHashMap(); + InteractionInfo + readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readOperationalDatasetComponentsAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .OperationalDatasetComponentsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback(), + readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readOperationalDatasetComponentsAttribute", + readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readActiveNetworkFaultsListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .ActiveNetworkFaultsListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), + readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readActiveNetworkFaultsListAttribute", + readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readThreadNetworkDiagnosticsAttributeListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo); - Map readTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map readTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readHourFormatAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationHourFormatCommandParams - ); - readTimeFormatLocalizationInteractionInfo.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 - ); - readTimeFormatLocalizationInteractionInfo.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 - ); - readTimeFormatLocalizationInteractionInfo.put("readSupportedCalendarTypesAttribute", readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); - Map readTimeFormatLocalizationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationClusterRevisionCommandParams - ); - readTimeFormatLocalizationInteractionInfo.put("readClusterRevisionAttribute", readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo); - Map readUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map readUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readTemperatureUnitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitLocalizationTemperatureUnitCommandParams - ); - readUnitLocalizationInteractionInfo.put("readTemperatureUnitAttribute", readUnitLocalizationTemperatureUnitAttributeInteractionInfo); - Map readUnitLocalizationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsFeatureMapCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo); + Map readTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); + Map readTimeFormatLocalizationHourFormatCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readHourFormatAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationHourFormatCommandParams); + readTimeFormatLocalizationInteractionInfo.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); + readTimeFormatLocalizationInteractionInfo.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); + readTimeFormatLocalizationInteractionInfo.put( + "readSupportedCalendarTypesAttribute", + readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); + Map readTimeFormatLocalizationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationClusterRevisionCommandParams); + readTimeFormatLocalizationInteractionInfo.put( + "readClusterRevisionAttribute", + readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo); + Map readUnitLocalizationInteractionInfo = new LinkedHashMap<>(); + Map readUnitLocalizationTemperatureUnitCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readTemperatureUnitAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitLocalizationTemperatureUnitCommandParams); + readUnitLocalizationInteractionInfo.put( + "readTemperatureUnitAttribute", + readUnitLocalizationTemperatureUnitAttributeInteractionInfo); + Map readUnitLocalizationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitLocalizationFeatureMapCommandParams - ); - readUnitLocalizationInteractionInfo.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 - ); - readUnitLocalizationInteractionInfo.put("readClusterRevisionAttribute", readUnitLocalizationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("unitLocalization", readUnitLocalizationInteractionInfo); - Map readUserLabelInteractionInfo = new LinkedHashMap<>(); - Map readUserLabelLabelListCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelLabelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readLabelListAttribute( - ( ChipClusters.UserLabelCluster.LabelListAttributeCallback - ) callback - ); - }, + readUnitLocalizationFeatureMapCommandParams); + readUnitLocalizationInteractionInfo.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); + readUnitLocalizationInteractionInfo.put( + "readClusterRevisionAttribute", + readUnitLocalizationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("unitLocalization", readUnitLocalizationInteractionInfo); + Map readUserLabelInteractionInfo = 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 - ); - readUserLabelInteractionInfo.put("readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); - Map readUserLabelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUserLabelClusterRevisionCommandParams - ); - readUserLabelInteractionInfo.put("readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("userLabel", readUserLabelInteractionInfo); - Map readWakeOnLanInteractionInfo = new LinkedHashMap<>(); - Map readWakeOnLanWakeOnLanMacAddressCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readWakeOnLanMacAddressAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readUserLabelLabelListCommandParams); + readUserLabelInteractionInfo.put( + "readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); + Map readUserLabelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUserLabelClusterRevisionCommandParams); + readUserLabelInteractionInfo.put( + "readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("userLabel", readUserLabelInteractionInfo); + Map readWakeOnLanInteractionInfo = new LinkedHashMap<>(); + Map readWakeOnLanWakeOnLanMacAddressCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readWakeOnLanMacAddressAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readWakeOnLanWakeOnLanMacAddressCommandParams - ); - readWakeOnLanInteractionInfo.put("readWakeOnLanMacAddressAttribute", readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo); - Map readWakeOnLanAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readAttributeListAttribute( - ( ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback - ) callback - ); - }, + readWakeOnLanWakeOnLanMacAddressCommandParams); + readWakeOnLanInteractionInfo.put( + "readWakeOnLanMacAddressAttribute", + readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo); + Map readWakeOnLanAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterAttributeListAttributeCallback(), - readWakeOnLanAttributeListCommandParams - ); - readWakeOnLanInteractionInfo.put("readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); - Map readWakeOnLanClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWakeOnLanClusterRevisionCommandParams - ); - readWakeOnLanInteractionInfo.put("readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("wakeOnLan", readWakeOnLanInteractionInfo); - Map readWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - Map readWiFiNetworkDiagnosticsBssidCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBssidAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readWakeOnLanAttributeListCommandParams); + readWakeOnLanInteractionInfo.put( + "readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); + Map readWakeOnLanClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWakeOnLanClusterRevisionCommandParams); + readWakeOnLanInteractionInfo.put( + "readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wakeOnLan", readWakeOnLanInteractionInfo); + Map readWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + Map readWiFiNetworkDiagnosticsBssidCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBssidAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readWiFiNetworkDiagnosticsBssidCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readSecurityTypeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsSecurityTypeCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readSecurityTypeAttribute", readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readWiFiVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsWiFiVersionCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readChannelNumberAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsChannelNumberCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readChannelNumberAttribute", readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsRssiCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readRssiAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsRssiCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconLostCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsBssidCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readSecurityTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsSecurityTypeCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readSecurityTypeAttribute", + readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readWiFiVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsWiFiVersionCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readChannelNumberAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsChannelNumberCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readChannelNumberAttribute", + readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsRssiCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readRssiAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsRssiCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBeaconLostCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconLostCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readBeaconLostCountAttribute", readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsBeaconLostCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readBeaconLostCountAttribute", + readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBeaconRxCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconRxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readBeaconRxCountAttribute", readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsBeaconRxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readBeaconRxCountAttribute", + readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); + Map + readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketMulticastRxCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketMulticastRxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastTxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketMulticastRxCountAttribute", + readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); + Map + readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketMulticastTxCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketMulticastTxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketMulticastTxCountAttribute", + readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketUnicastRxCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketUnicastRxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastTxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketUnicastRxCountAttribute", + readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketUnicastTxCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketUnicastTxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readCurrentMaxRateAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketUnicastTxCountAttribute", + readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readCurrentMaxRateAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readCurrentMaxRateAttribute", readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readCurrentMaxRateAttribute", + readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsOverrunCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readWiFiNetworkDiagnosticsAttributeListCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readAttributeListAttribute", readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsOverrunCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readOverrunCountAttribute", + readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readWiFiNetworkDiagnosticsAttributeListCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.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 - ); - readWiFiNetworkDiagnosticsInteractionInfo.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 - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo); - Map readWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map readWindowCoveringTypeCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTypeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTypeCommandParams - ); - readWindowCoveringInteractionInfo.put("readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionLiftAttribute", readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionTiltAttribute", readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); - Map readWindowCoveringConfigStatusCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readConfigStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringConfigStatusCommandParams - ); - readWindowCoveringInteractionInfo.put("readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercentageAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercentageAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercentageCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionLiftPercentageAttribute", readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercentageAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercentageAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercentageCommandParams - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readOperationalStatusAttribute", readWindowCoveringOperationalStatusAttributeInteractionInfo); - Map readWindowCoveringTargetPositionLiftPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionLiftPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.TargetPositionLiftPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTargetPositionLiftPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.put("readTargetPositionLiftPercent100thsAttribute", readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); - Map readWindowCoveringTargetPositionTiltPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionTiltPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.TargetPositionTiltPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTargetPositionTiltPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionLiftPercent100thsAttribute", readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); - Map readWindowCoveringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readAttributeListAttribute( - ( ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterAttributeListAttributeCallback(), - readWindowCoveringAttributeListCommandParams - ); - readWindowCoveringInteractionInfo.put("readAttributeListAttribute", readWindowCoveringAttributeListAttributeInteractionInfo); - Map readWindowCoveringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsFeatureMapCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.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); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo); + Map readWindowCoveringInteractionInfo = new LinkedHashMap<>(); + Map readWindowCoveringTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTypeCommandParams); + readWindowCoveringInteractionInfo.put( + "readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionLiftAttribute", + readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionTiltAttribute", + readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); + Map readWindowCoveringConfigStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readConfigStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringConfigStatusCommandParams); + readWindowCoveringInteractionInfo.put( + "readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftPercentageAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionLiftPercentageAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercentageCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionLiftPercentageAttribute", + readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltPercentageAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionTiltPercentageAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercentageCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readOperationalStatusAttribute", + readWindowCoveringOperationalStatusAttributeInteractionInfo); + Map + readWindowCoveringTargetPositionLiftPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTargetPositionLiftPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .TargetPositionLiftPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTargetPositionLiftPercent100thsCommandParams); + readWindowCoveringInteractionInfo.put( + "readTargetPositionLiftPercent100thsAttribute", + readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); + Map + readWindowCoveringTargetPositionTiltPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTargetPositionTiltPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .TargetPositionTiltPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTargetPositionTiltPercent100thsCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); + Map + readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionLiftPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercent100thsCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionLiftPercent100thsAttribute", + readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); + Map + readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionTiltPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercent100thsCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); + Map readWindowCoveringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterAttributeListAttributeCallback(), + readWindowCoveringAttributeListCommandParams); + readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("windowCovering", readWindowCoveringInteractionInfo); - return readAttributeMap; + readWindowCoveringFeatureMapCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("windowCovering", readWindowCoveringInteractionInfo); + return readAttributeMap; } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java index e701c60d01ca31..4ee787dfd94515 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java @@ -29,2292 +29,2466 @@ public class ClusterWriteMapping { public Map> getWriteAttributeMap() { Map> writeAttributeMap = new HashMap<>(); - Map writeAccessControlInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("accessControl", writeAccessControlInteractionInfo); - Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); - Map writeAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("administratorCommissioning", writeAdministratorCommissioningInteractionInfo); - Map writeApplicationBasicInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("applicationBasic", writeApplicationBasicInteractionInfo); - Map writeApplicationLauncherInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("applicationLauncher", writeApplicationLauncherInteractionInfo); - Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); - Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); - Map writeBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBasicNodeLabelCommandParams = new LinkedHashMap(); - CommandParameterInfo basicnodeLabelCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeBasicNodeLabelCommandParams.put("value",basicnodeLabelCommandParameterInfo); - InteractionInfo writeBasicNodeLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).writeNodeLabelAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicNodeLabelCommandParams - ); - writeBasicInteractionInfo.put("writeNodeLabelAttribute", writeBasicNodeLabelAttributeInteractionInfo); - Map writeBasicLocationCommandParams = new LinkedHashMap(); - CommandParameterInfo basiclocationCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeBasicLocationCommandParams.put("value",basiclocationCommandParameterInfo); - InteractionInfo writeBasicLocationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).writeLocationAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicLocationCommandParams - ); - writeBasicInteractionInfo.put("writeLocationAttribute", writeBasicLocationAttributeInteractionInfo); - Map writeBasicLocalConfigDisabledCommandParams = new LinkedHashMap(); - CommandParameterInfo basiclocalConfigDisabledCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeBasicLocalConfigDisabledCommandParams.put("value",basiclocalConfigDisabledCommandParameterInfo); - InteractionInfo writeBasicLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).writeLocalConfigDisabledAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicLocalConfigDisabledCommandParams - ); - writeBasicInteractionInfo.put("writeLocalConfigDisabledAttribute", writeBasicLocalConfigDisabledAttributeInteractionInfo); - writeAttributeMap.put("basic", writeBasicInteractionInfo); - Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); - CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); - Map writeBindingInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("binding", writeBindingInteractionInfo); - Map writeBooleanStateInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("booleanState", writeBooleanStateInteractionInfo); - Map writeBridgedActionsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("bridgedActions", writeBridgedActionsInteractionInfo); - Map writeBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("bridgedDeviceBasic", writeBridgedDeviceBasicInteractionInfo); - Map writeChannelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("channel", writeChannelInteractionInfo); - Map writeColorControlInteractionInfo = new LinkedHashMap<>(); - Map writeColorControlColorControlOptionsCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlcolorControlOptionsCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeColorControlColorControlOptionsCommandParams.put("value",colorControlcolorControlOptionsCommandParameterInfo); - InteractionInfo writeColorControlColorControlOptionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorControlOptionsAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorControlOptionsCommandParams - ); - writeColorControlInteractionInfo.put("writeColorControlOptionsAttribute", writeColorControlColorControlOptionsAttributeInteractionInfo); - Map writeColorControlWhitePointXCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlwhitePointXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlwhitePointYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); - Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map writeContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); - CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); - Map writeDescriptorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("descriptor", writeDescriptorInteractionInfo); - Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); - Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); - Map writeDoorLockLanguageCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocklanguageCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = new CommandParameterInfo("value", 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); - 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 writeDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); - Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); - Map writeEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); - Map writeFixedLabelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("fixedLabel", writeFixedLabelInteractionInfo); - Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); - Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); - CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); - Map writeGeneralDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); - Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("groupKeyManagement", writeGroupKeyManagementInteractionInfo); - Map writeGroupsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("groups", writeGroupsInteractionInfo); - Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); - Map writeIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); - CommandParameterInfo identifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("value", 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 writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); - Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); - Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); - Map writeLevelControlOptionsCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControloptionsCommandParameterInfo = new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo levelControlonLevelCommandParameterInfo = new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); - Map writeLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); - Map writeLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); - CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = new CommandParameterInfo("value", 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); - Map writeLowPowerInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("lowPower", writeLowPowerInteractionInfo); - Map writeMediaInputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("mediaInput", writeMediaInputInteractionInfo); - Map writeMediaPlaybackInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("mediaPlayback", writeMediaPlaybackInteractionInfo); - Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); - Map writeModeSelectOnModeCommandParams = new LinkedHashMap(); - CommandParameterInfo modeSelectonModeCommandParameterInfo = new CommandParameterInfo("value", 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 writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); - Map writeOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); - Map writeOtaSoftwareUpdateRequestorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); - Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); - Map writeOnOffInteractionInfo = new LinkedHashMap<>(); - Map writeOnOffOnTimeCommandParams = new LinkedHashMap(); - CommandParameterInfo onOffonTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); - Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); - Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); - Map writePowerSourceConfigurationInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); - Map writePressureMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); - Map writePumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); - Map writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); - CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = new CommandParameterInfo("value", 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); - Map writeRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); - Map writeScenesInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("scenes", writeScenesInteractionInfo); - Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); - Map writeSwitchInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("switch", writeSwitchInteractionInfo); - Map writeTargetNavigatorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("targetNavigator", writeTargetNavigatorInteractionInfo); - Map writeTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("temperatureMeasurement", writeTemperatureMeasurementInteractionInfo); - Map writeTestClusterInteractionInfo = new LinkedHashMap<>(); - Map writeTestClusterBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterBooleanCommandParams.put("value",testClusterbooleanCommandParameterInfo); - InteractionInfo writeTestClusterBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeBooleanAttribute", writeTestClusterBooleanAttributeInteractionInfo); - Map writeTestClusterBitmap8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterBitmap8CommandParams.put("value",testClusterbitmap8CommandParameterInfo); - InteractionInfo writeTestClusterBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap8CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap8Attribute", writeTestClusterBitmap8AttributeInteractionInfo); - Map writeTestClusterBitmap16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterBitmap16CommandParams.put("value",testClusterbitmap16CommandParameterInfo); - InteractionInfo writeTestClusterBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap16CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap16Attribute", writeTestClusterBitmap16AttributeInteractionInfo); - Map writeTestClusterBitmap32CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap32CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterBitmap32CommandParams.put("value",testClusterbitmap32CommandParameterInfo); - InteractionInfo writeTestClusterBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap32Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap32CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap32Attribute", writeTestClusterBitmap32AttributeInteractionInfo); - Map writeTestClusterBitmap64CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap64CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterBitmap64CommandParams.put("value",testClusterbitmap64CommandParameterInfo); - InteractionInfo writeTestClusterBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap64Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap64CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap64Attribute", writeTestClusterBitmap64AttributeInteractionInfo); - Map writeTestClusterInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt8uCommandParams.put("value",testClusterint8uCommandParameterInfo); - InteractionInfo writeTestClusterInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt8uAttribute", writeTestClusterInt8uAttributeInteractionInfo); - Map writeTestClusterInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt16uCommandParams.put("value",testClusterint16uCommandParameterInfo); - InteractionInfo writeTestClusterInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt16uAttribute", writeTestClusterInt16uAttributeInteractionInfo); - Map writeTestClusterInt24uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint24uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt24uCommandParams.put("value",testClusterint24uCommandParameterInfo); - InteractionInfo writeTestClusterInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt24uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt24uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt24uAttribute", writeTestClusterInt24uAttributeInteractionInfo); - Map writeTestClusterInt32uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint32uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt32uCommandParams.put("value",testClusterint32uCommandParameterInfo); - InteractionInfo writeTestClusterInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt32uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt32uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt32uAttribute", writeTestClusterInt32uAttributeInteractionInfo); - Map writeTestClusterInt40uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint40uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt40uCommandParams.put("value",testClusterint40uCommandParameterInfo); - InteractionInfo writeTestClusterInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt40uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt40uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt40uAttribute", writeTestClusterInt40uAttributeInteractionInfo); - Map writeTestClusterInt48uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint48uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt48uCommandParams.put("value",testClusterint48uCommandParameterInfo); - InteractionInfo writeTestClusterInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt48uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt48uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt48uAttribute", writeTestClusterInt48uAttributeInteractionInfo); - Map writeTestClusterInt56uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint56uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt56uCommandParams.put("value",testClusterint56uCommandParameterInfo); - InteractionInfo writeTestClusterInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt56uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt56uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt56uAttribute", writeTestClusterInt56uAttributeInteractionInfo); - Map writeTestClusterInt64uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint64uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt64uCommandParams.put("value",testClusterint64uCommandParameterInfo); - InteractionInfo writeTestClusterInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt64uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt64uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt64uAttribute", writeTestClusterInt64uAttributeInteractionInfo); - Map writeTestClusterInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt8sCommandParams.put("value",testClusterint8sCommandParameterInfo); - InteractionInfo writeTestClusterInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt8sAttribute", writeTestClusterInt8sAttributeInteractionInfo); - Map writeTestClusterInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt16sCommandParams.put("value",testClusterint16sCommandParameterInfo); - InteractionInfo writeTestClusterInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt16sAttribute", writeTestClusterInt16sAttributeInteractionInfo); - Map writeTestClusterInt24sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint24sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt24sCommandParams.put("value",testClusterint24sCommandParameterInfo); - InteractionInfo writeTestClusterInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt24sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt24sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt24sAttribute", writeTestClusterInt24sAttributeInteractionInfo); - Map writeTestClusterInt32sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint32sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt32sCommandParams.put("value",testClusterint32sCommandParameterInfo); - InteractionInfo writeTestClusterInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt32sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt32sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt32sAttribute", writeTestClusterInt32sAttributeInteractionInfo); - Map writeTestClusterInt40sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint40sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt40sCommandParams.put("value",testClusterint40sCommandParameterInfo); - InteractionInfo writeTestClusterInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt40sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt40sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt40sAttribute", writeTestClusterInt40sAttributeInteractionInfo); - Map writeTestClusterInt48sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint48sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt48sCommandParams.put("value",testClusterint48sCommandParameterInfo); - InteractionInfo writeTestClusterInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt48sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt48sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt48sAttribute", writeTestClusterInt48sAttributeInteractionInfo); - Map writeTestClusterInt56sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint56sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt56sCommandParams.put("value",testClusterint56sCommandParameterInfo); - InteractionInfo writeTestClusterInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt56sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt56sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt56sAttribute", writeTestClusterInt56sAttributeInteractionInfo); - Map writeTestClusterInt64sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint64sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt64sCommandParams.put("value",testClusterint64sCommandParameterInfo); - InteractionInfo writeTestClusterInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt64sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt64sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt64sAttribute", writeTestClusterInt64sAttributeInteractionInfo); - Map writeTestClusterEnum8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterenum8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterEnum8CommandParams.put("value",testClusterenum8CommandParameterInfo); - InteractionInfo writeTestClusterEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEnum8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnum8CommandParams - ); - writeTestClusterInteractionInfo.put("writeEnum8Attribute", writeTestClusterEnum8AttributeInteractionInfo); - Map writeTestClusterEnum16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterenum16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterEnum16CommandParams.put("value",testClusterenum16CommandParameterInfo); - InteractionInfo writeTestClusterEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEnum16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnum16CommandParams - ); - writeTestClusterInteractionInfo.put("writeEnum16Attribute", writeTestClusterEnum16AttributeInteractionInfo); - Map writeTestClusterFloatSingleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterfloatSingleCommandParameterInfo = new CommandParameterInfo("value", Float.class); - writeTestClusterFloatSingleCommandParams.put("value",testClusterfloatSingleCommandParameterInfo); - InteractionInfo writeTestClusterFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeFloatSingleAttribute( - (DefaultClusterCallback) callback, - (Float) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterFloatSingleCommandParams - ); - writeTestClusterInteractionInfo.put("writeFloatSingleAttribute", writeTestClusterFloatSingleAttributeInteractionInfo); - Map writeTestClusterFloatDoubleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterfloatDoubleCommandParameterInfo = new CommandParameterInfo("value", Double.class); - writeTestClusterFloatDoubleCommandParams.put("value",testClusterfloatDoubleCommandParameterInfo); - InteractionInfo writeTestClusterFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeFloatDoubleAttribute( - (DefaultClusterCallback) callback, - (Double) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterFloatDoubleCommandParams - ); - writeTestClusterInteractionInfo.put("writeFloatDoubleAttribute", writeTestClusterFloatDoubleAttributeInteractionInfo); - Map writeTestClusterOctetStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusteroctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); - writeTestClusterOctetStringCommandParams.put("value",testClusteroctetStringCommandParameterInfo); - InteractionInfo writeTestClusterOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterOctetStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeOctetStringAttribute", writeTestClusterOctetStringAttributeInteractionInfo); - Map writeTestClusterLongOctetStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterlongOctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); - writeTestClusterLongOctetStringCommandParams.put("value",testClusterlongOctetStringCommandParameterInfo); - InteractionInfo writeTestClusterLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeLongOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterLongOctetStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeLongOctetStringAttribute", writeTestClusterLongOctetStringAttributeInteractionInfo); - Map writeTestClusterCharStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustercharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeTestClusterCharStringCommandParams.put("value",testClustercharStringCommandParameterInfo); - InteractionInfo writeTestClusterCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeCharStringAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterCharStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeCharStringAttribute", writeTestClusterCharStringAttributeInteractionInfo); - Map writeTestClusterLongCharStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterlongCharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeTestClusterLongCharStringCommandParams.put("value",testClusterlongCharStringCommandParameterInfo); - InteractionInfo writeTestClusterLongCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeLongCharStringAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterLongCharStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeLongCharStringAttribute", writeTestClusterLongCharStringAttributeInteractionInfo); - Map writeTestClusterEpochUsCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterepochUsCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterEpochUsCommandParams.put("value",testClusterepochUsCommandParameterInfo); - InteractionInfo writeTestClusterEpochUsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEpochUsAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEpochUsCommandParams - ); - writeTestClusterInteractionInfo.put("writeEpochUsAttribute", writeTestClusterEpochUsAttributeInteractionInfo); - Map writeTestClusterEpochSCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterepochSCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterEpochSCommandParams.put("value",testClusterepochSCommandParameterInfo); - InteractionInfo writeTestClusterEpochSAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEpochSAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEpochSCommandParams - ); - writeTestClusterInteractionInfo.put("writeEpochSAttribute", writeTestClusterEpochSAttributeInteractionInfo); - Map writeTestClusterVendorIdCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustervendorIdCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterVendorIdCommandParams.put("value",testClustervendorIdCommandParameterInfo); - InteractionInfo writeTestClusterVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeVendorIdAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterVendorIdCommandParams - ); - writeTestClusterInteractionInfo.put("writeVendorIdAttribute", writeTestClusterVendorIdAttributeInteractionInfo); - Map writeTestClusterEnumAttrCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterenumAttrCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterEnumAttrCommandParams.put("value",testClusterenumAttrCommandParameterInfo); - InteractionInfo writeTestClusterEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEnumAttrAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnumAttrCommandParams - ); - writeTestClusterInteractionInfo.put("writeEnumAttrAttribute", writeTestClusterEnumAttrAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt8uCommandParams.put("value",testClusterrangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt8uAttribute", writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt8sCommandParams.put("value",testClusterrangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt8sAttribute", writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt16uCommandParams.put("value",testClusterrangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt16uAttribute", writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt16sCommandParams.put("value",testClusterrangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt16sAttribute", writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo); - Map writeTestClusterTimedWriteBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertimedWriteBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterTimedWriteBooleanCommandParams.put("value",testClustertimedWriteBooleanCommandParameterInfo); - InteractionInfo writeTestClusterTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeTimedWriteBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - , 10000 - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterTimedWriteBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeTimedWriteBooleanAttribute", writeTestClusterTimedWriteBooleanAttributeInteractionInfo); - Map writeTestClusterGeneralErrorBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustergeneralErrorBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterGeneralErrorBooleanCommandParams.put("value",testClustergeneralErrorBooleanCommandParameterInfo); - InteractionInfo writeTestClusterGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeGeneralErrorBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterGeneralErrorBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeGeneralErrorBooleanAttribute", writeTestClusterGeneralErrorBooleanAttributeInteractionInfo); - Map writeTestClusterClusterErrorBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterclusterErrorBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterClusterErrorBooleanCommandParams.put("value",testClusterclusterErrorBooleanCommandParameterInfo); - InteractionInfo writeTestClusterClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeClusterErrorBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterClusterErrorBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeClusterErrorBooleanAttribute", writeTestClusterClusterErrorBooleanAttributeInteractionInfo); - Map writeTestClusterUnsupportedCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterunsupportedCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterUnsupportedCommandParams.put("value",testClusterunsupportedCommandParameterInfo); - InteractionInfo writeTestClusterUnsupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeUnsupportedAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterUnsupportedCommandParams - ); - writeTestClusterInteractionInfo.put("writeUnsupportedAttribute", writeTestClusterUnsupportedAttributeInteractionInfo); - Map writeTestClusterNullableBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterNullableBooleanCommandParams.put("value",testClusternullableBooleanCommandParameterInfo); - InteractionInfo writeTestClusterNullableBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBooleanAttribute", writeTestClusterNullableBooleanAttributeInteractionInfo); - Map writeTestClusterNullableBitmap8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableBitmap8CommandParams.put("value",testClusternullableBitmap8CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap8CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap8Attribute", writeTestClusterNullableBitmap8AttributeInteractionInfo); - Map writeTestClusterNullableBitmap16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableBitmap16CommandParams.put("value",testClusternullableBitmap16CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap16CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap16Attribute", writeTestClusterNullableBitmap16AttributeInteractionInfo); - Map writeTestClusterNullableBitmap32CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap32CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableBitmap32CommandParams.put("value",testClusternullableBitmap32CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap32Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap32CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap32Attribute", writeTestClusterNullableBitmap32AttributeInteractionInfo); - Map writeTestClusterNullableBitmap64CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap64CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableBitmap64CommandParams.put("value",testClusternullableBitmap64CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap64Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap64CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap64Attribute", writeTestClusterNullableBitmap64AttributeInteractionInfo); - Map writeTestClusterNullableInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt8uCommandParams.put("value",testClusternullableInt8uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt8uAttribute", writeTestClusterNullableInt8uAttributeInteractionInfo); - Map writeTestClusterNullableInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt16uCommandParams.put("value",testClusternullableInt16uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt16uAttribute", writeTestClusterNullableInt16uAttributeInteractionInfo); - Map writeTestClusterNullableInt24uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt24uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt24uCommandParams.put("value",testClusternullableInt24uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt24uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt24uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt24uAttribute", writeTestClusterNullableInt24uAttributeInteractionInfo); - Map writeTestClusterNullableInt32uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt32uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt32uCommandParams.put("value",testClusternullableInt32uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt32uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt32uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt32uAttribute", writeTestClusterNullableInt32uAttributeInteractionInfo); - Map writeTestClusterNullableInt40uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt40uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt40uCommandParams.put("value",testClusternullableInt40uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt40uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt40uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt40uAttribute", writeTestClusterNullableInt40uAttributeInteractionInfo); - Map writeTestClusterNullableInt48uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt48uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt48uCommandParams.put("value",testClusternullableInt48uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt48uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt48uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt48uAttribute", writeTestClusterNullableInt48uAttributeInteractionInfo); - Map writeTestClusterNullableInt56uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt56uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt56uCommandParams.put("value",testClusternullableInt56uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt56uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt56uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt56uAttribute", writeTestClusterNullableInt56uAttributeInteractionInfo); - Map writeTestClusterNullableInt64uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt64uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt64uCommandParams.put("value",testClusternullableInt64uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt64uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt64uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt64uAttribute", writeTestClusterNullableInt64uAttributeInteractionInfo); - Map writeTestClusterNullableInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt8sCommandParams.put("value",testClusternullableInt8sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt8sAttribute", writeTestClusterNullableInt8sAttributeInteractionInfo); - Map writeTestClusterNullableInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt16sCommandParams.put("value",testClusternullableInt16sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt16sAttribute", writeTestClusterNullableInt16sAttributeInteractionInfo); - Map writeTestClusterNullableInt24sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt24sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt24sCommandParams.put("value",testClusternullableInt24sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt24sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt24sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt24sAttribute", writeTestClusterNullableInt24sAttributeInteractionInfo); - Map writeTestClusterNullableInt32sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt32sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt32sCommandParams.put("value",testClusternullableInt32sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt32sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt32sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt32sAttribute", writeTestClusterNullableInt32sAttributeInteractionInfo); - Map writeTestClusterNullableInt40sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt40sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt40sCommandParams.put("value",testClusternullableInt40sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt40sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt40sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt40sAttribute", writeTestClusterNullableInt40sAttributeInteractionInfo); - Map writeTestClusterNullableInt48sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt48sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt48sCommandParams.put("value",testClusternullableInt48sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt48sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt48sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt48sAttribute", writeTestClusterNullableInt48sAttributeInteractionInfo); - Map writeTestClusterNullableInt56sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt56sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt56sCommandParams.put("value",testClusternullableInt56sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt56sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt56sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt56sAttribute", writeTestClusterNullableInt56sAttributeInteractionInfo); - Map writeTestClusterNullableInt64sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt64sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt64sCommandParams.put("value",testClusternullableInt64sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt64sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt64sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt64sAttribute", writeTestClusterNullableInt64sAttributeInteractionInfo); - Map writeTestClusterNullableEnum8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableEnum8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnum8CommandParams.put("value",testClusternullableEnum8CommandParameterInfo); - InteractionInfo writeTestClusterNullableEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableEnum8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnum8CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableEnum8Attribute", writeTestClusterNullableEnum8AttributeInteractionInfo); - Map writeTestClusterNullableEnum16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableEnum16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnum16CommandParams.put("value",testClusternullableEnum16CommandParameterInfo); - InteractionInfo writeTestClusterNullableEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableEnum16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnum16CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableEnum16Attribute", writeTestClusterNullableEnum16AttributeInteractionInfo); - Map writeTestClusterNullableFloatSingleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableFloatSingleCommandParameterInfo = new CommandParameterInfo("value", Float.class); - writeTestClusterNullableFloatSingleCommandParams.put("value",testClusternullableFloatSingleCommandParameterInfo); - InteractionInfo writeTestClusterNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableFloatSingleAttribute( - (DefaultClusterCallback) callback, - (Float) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableFloatSingleCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableFloatSingleAttribute", writeTestClusterNullableFloatSingleAttributeInteractionInfo); - Map writeTestClusterNullableFloatDoubleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableFloatDoubleCommandParameterInfo = new CommandParameterInfo("value", Double.class); - writeTestClusterNullableFloatDoubleCommandParams.put("value",testClusternullableFloatDoubleCommandParameterInfo); - InteractionInfo writeTestClusterNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableFloatDoubleAttribute( - (DefaultClusterCallback) callback, - (Double) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableFloatDoubleCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableFloatDoubleAttribute", writeTestClusterNullableFloatDoubleAttributeInteractionInfo); - Map writeTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableOctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); - writeTestClusterNullableOctetStringCommandParams.put("value",testClusternullableOctetStringCommandParameterInfo); - InteractionInfo writeTestClusterNullableOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableOctetStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableOctetStringAttribute", writeTestClusterNullableOctetStringAttributeInteractionInfo); - Map writeTestClusterNullableCharStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableCharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeTestClusterNullableCharStringCommandParams.put("value",testClusternullableCharStringCommandParameterInfo); - InteractionInfo writeTestClusterNullableCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableCharStringAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableCharStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableCharStringAttribute", writeTestClusterNullableCharStringAttributeInteractionInfo); - Map writeTestClusterNullableEnumAttrCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableEnumAttrCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnumAttrCommandParams.put("value",testClusternullableEnumAttrCommandParameterInfo); - InteractionInfo writeTestClusterNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableEnumAttrAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnumAttrCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableEnumAttrAttribute", writeTestClusterNullableEnumAttrAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt8uCommandParams.put("value",testClusternullableRangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt8uAttribute", writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt8sCommandParams.put("value",testClusternullableRangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt8sAttribute", writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt16uCommandParams.put("value",testClusternullableRangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt16uAttribute", writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt16sCommandParams.put("value",testClusternullableRangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt16sAttribute", writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); - writeAttributeMap.put("testCluster", writeTestClusterInteractionInfo); - Map writeThermostatInteractionInfo = new LinkedHashMap<>(); - Map writeThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = new CommandParameterInfo("value", 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 writeThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = new CommandParameterInfo("value", 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 writeThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatsystemModeCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); - Map writeThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); - Map writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = new CommandParameterInfo("value", 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); - 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); - Map writeThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); - Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); - CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); - Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); - CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); - Map writeUserLabelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("userLabel", writeUserLabelInteractionInfo); - Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); - Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); - Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map writeWindowCoveringModeCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringmodeCommandParameterInfo = new CommandParameterInfo("value", 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 writeAccessControlInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("accessControl", writeAccessControlInteractionInfo); + Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); + Map writeAdministratorCommissioningInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "administratorCommissioning", writeAdministratorCommissioningInteractionInfo); + Map writeApplicationBasicInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("applicationBasic", writeApplicationBasicInteractionInfo); + Map writeApplicationLauncherInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("applicationLauncher", writeApplicationLauncherInteractionInfo); + Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); + Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); + Map writeBasicInteractionInfo = new LinkedHashMap<>(); + Map writeBasicNodeLabelCommandParams = + new LinkedHashMap(); + CommandParameterInfo basicnodeLabelCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeBasicNodeLabelCommandParams.put("value", basicnodeLabelCommandParameterInfo); + InteractionInfo writeBasicNodeLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .writeNodeLabelAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicNodeLabelCommandParams); + writeBasicInteractionInfo.put( + "writeNodeLabelAttribute", writeBasicNodeLabelAttributeInteractionInfo); + Map writeBasicLocationCommandParams = + new LinkedHashMap(); + CommandParameterInfo basiclocationCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeBasicLocationCommandParams.put("value", basiclocationCommandParameterInfo); + InteractionInfo writeBasicLocationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .writeLocationAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicLocationCommandParams); + writeBasicInteractionInfo.put( + "writeLocationAttribute", writeBasicLocationAttributeInteractionInfo); + Map writeBasicLocalConfigDisabledCommandParams = + new LinkedHashMap(); + CommandParameterInfo basiclocalConfigDisabledCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeBasicLocalConfigDisabledCommandParams.put( + "value", basiclocalConfigDisabledCommandParameterInfo); + InteractionInfo writeBasicLocalConfigDisabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .writeLocalConfigDisabledAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicLocalConfigDisabledCommandParams); + writeBasicInteractionInfo.put( + "writeLocalConfigDisabledAttribute", writeBasicLocalConfigDisabledAttributeInteractionInfo); + writeAttributeMap.put("basic", writeBasicInteractionInfo); + Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); + Map writeBinaryInputBasicOutOfServiceCommandParams = + new LinkedHashMap(); + CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); + Map writeBindingInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("binding", writeBindingInteractionInfo); + Map writeBooleanStateInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("booleanState", writeBooleanStateInteractionInfo); + Map writeBridgedActionsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bridgedActions", writeBridgedActionsInteractionInfo); + Map writeBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bridgedDeviceBasic", writeBridgedDeviceBasicInteractionInfo); + Map writeChannelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("channel", writeChannelInteractionInfo); + Map writeColorControlInteractionInfo = new LinkedHashMap<>(); + Map writeColorControlColorControlOptionsCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlcolorControlOptionsCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeColorControlColorControlOptionsCommandParams.put( + "value", colorControlcolorControlOptionsCommandParameterInfo); + InteractionInfo writeColorControlColorControlOptionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorControlOptionsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorControlOptionsCommandParams); + writeColorControlInteractionInfo.put( + "writeColorControlOptionsAttribute", + writeColorControlColorControlOptionsAttributeInteractionInfo); + Map writeColorControlWhitePointXCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlwhitePointXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlwhitePointYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); + Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); + Map writeContentLauncherSupportedStreamingProtocolsCommandParams = + new LinkedHashMap(); + CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); + Map writeDescriptorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("descriptor", writeDescriptorInteractionInfo); + Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); + Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); + Map writeDoorLockLanguageCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocklanguageCommandParameterInfo = + new CommandParameterInfo("value", 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 writeDoorLockAutoRelockTimeCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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 writeDoorLockEnableOneTouchLockingCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = + new CommandParameterInfo("value", 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 writeDoorLockEnablePrivacyModeButtonCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = + new CommandParameterInfo("value", 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 writeDoorLockWrongCodeEntryLimitCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); + Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); + Map writeEthernetNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); + Map writeFixedLabelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("fixedLabel", writeFixedLabelInteractionInfo); + Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); + Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); + Map writeGeneralCommissioningBreadcrumbCommandParams = + new LinkedHashMap(); + CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); + Map writeGeneralDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); + Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("groupKeyManagement", writeGroupKeyManagementInteractionInfo); + Map writeGroupsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("groups", writeGroupsInteractionInfo); + Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); + Map writeIdentifyIdentifyTimeCommandParams = + new LinkedHashMap(); + CommandParameterInfo identifyidentifyTimeCommandParameterInfo = + new CommandParameterInfo("value", 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 writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); + Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); + Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); + Map writeLevelControlOptionsCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControloptionsCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo levelControlonLevelCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); + Map writeLocalizationConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map writeLocalizationConfigurationActiveLocaleCommandParams = + new LinkedHashMap(); + CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = + new CommandParameterInfo("value", 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); + Map writeLowPowerInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("lowPower", writeLowPowerInteractionInfo); + Map writeMediaInputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("mediaInput", writeMediaInputInteractionInfo); + Map writeMediaPlaybackInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("mediaPlayback", writeMediaPlaybackInteractionInfo); + Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); + Map writeModeSelectOnModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo modeSelectonModeCommandParameterInfo = + new CommandParameterInfo("value", 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 writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); + Map writeNetworkCommissioningInterfaceEnabledCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); + Map writeOtaSoftwareUpdateProviderInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); + Map writeOtaSoftwareUpdateRequestorInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); + Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); + Map writeOnOffInteractionInfo = new LinkedHashMap<>(); + Map writeOnOffOnTimeCommandParams = + new LinkedHashMap(); + CommandParameterInfo onOffonTimeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); + Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); + Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); + Map writePowerSourceConfigurationInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); + Map writePressureMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); + Map writePumpConfigurationAndControlInteractionInfo = + new LinkedHashMap<>(); + Map + writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = + new LinkedHashMap(); + CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = + new CommandParameterInfo("value", 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); + Map writeRelativeHumidityMeasurementInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); + Map writeScenesInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("scenes", writeScenesInteractionInfo); + Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); + Map writeSwitchInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("switch", writeSwitchInteractionInfo); + Map writeTargetNavigatorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("targetNavigator", writeTargetNavigatorInteractionInfo); + Map writeTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("temperatureMeasurement", writeTemperatureMeasurementInteractionInfo); + Map writeTestClusterInteractionInfo = new LinkedHashMap<>(); + Map writeTestClusterBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterBooleanCommandParams.put("value", testClusterbooleanCommandParameterInfo); + InteractionInfo writeTestClusterBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeBooleanAttribute", writeTestClusterBooleanAttributeInteractionInfo); + Map writeTestClusterBitmap8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterBitmap8CommandParams.put("value", testClusterbitmap8CommandParameterInfo); + InteractionInfo writeTestClusterBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap8CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap8Attribute", writeTestClusterBitmap8AttributeInteractionInfo); + Map writeTestClusterBitmap16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterBitmap16CommandParams.put("value", testClusterbitmap16CommandParameterInfo); + InteractionInfo writeTestClusterBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap16CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap16Attribute", writeTestClusterBitmap16AttributeInteractionInfo); + Map writeTestClusterBitmap32CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap32CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterBitmap32CommandParams.put("value", testClusterbitmap32CommandParameterInfo); + InteractionInfo writeTestClusterBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap32Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap32CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap32Attribute", writeTestClusterBitmap32AttributeInteractionInfo); + Map writeTestClusterBitmap64CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap64CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterBitmap64CommandParams.put("value", testClusterbitmap64CommandParameterInfo); + InteractionInfo writeTestClusterBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap64Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap64CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap64Attribute", writeTestClusterBitmap64AttributeInteractionInfo); + Map writeTestClusterInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt8uCommandParams.put("value", testClusterint8uCommandParameterInfo); + InteractionInfo writeTestClusterInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt8uAttribute", writeTestClusterInt8uAttributeInteractionInfo); + Map writeTestClusterInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt16uCommandParams.put("value", testClusterint16uCommandParameterInfo); + InteractionInfo writeTestClusterInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt16uAttribute", writeTestClusterInt16uAttributeInteractionInfo); + Map writeTestClusterInt24uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint24uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt24uCommandParams.put("value", testClusterint24uCommandParameterInfo); + InteractionInfo writeTestClusterInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt24uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt24uAttribute", writeTestClusterInt24uAttributeInteractionInfo); + Map writeTestClusterInt32uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint32uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt32uCommandParams.put("value", testClusterint32uCommandParameterInfo); + InteractionInfo writeTestClusterInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt32uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt32uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt32uAttribute", writeTestClusterInt32uAttributeInteractionInfo); + Map writeTestClusterInt40uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint40uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt40uCommandParams.put("value", testClusterint40uCommandParameterInfo); + InteractionInfo writeTestClusterInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt40uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt40uAttribute", writeTestClusterInt40uAttributeInteractionInfo); + Map writeTestClusterInt48uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint48uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt48uCommandParams.put("value", testClusterint48uCommandParameterInfo); + InteractionInfo writeTestClusterInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt48uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt48uAttribute", writeTestClusterInt48uAttributeInteractionInfo); + Map writeTestClusterInt56uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint56uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt56uCommandParams.put("value", testClusterint56uCommandParameterInfo); + InteractionInfo writeTestClusterInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt56uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt56uAttribute", writeTestClusterInt56uAttributeInteractionInfo); + Map writeTestClusterInt64uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint64uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt64uCommandParams.put("value", testClusterint64uCommandParameterInfo); + InteractionInfo writeTestClusterInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt64uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt64uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt64uAttribute", writeTestClusterInt64uAttributeInteractionInfo); + Map writeTestClusterInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt8sCommandParams.put("value", testClusterint8sCommandParameterInfo); + InteractionInfo writeTestClusterInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt8sAttribute", writeTestClusterInt8sAttributeInteractionInfo); + Map writeTestClusterInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt16sCommandParams.put("value", testClusterint16sCommandParameterInfo); + InteractionInfo writeTestClusterInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt16sAttribute", writeTestClusterInt16sAttributeInteractionInfo); + Map writeTestClusterInt24sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint24sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt24sCommandParams.put("value", testClusterint24sCommandParameterInfo); + InteractionInfo writeTestClusterInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt24sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt24sAttribute", writeTestClusterInt24sAttributeInteractionInfo); + Map writeTestClusterInt32sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint32sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt32sCommandParams.put("value", testClusterint32sCommandParameterInfo); + InteractionInfo writeTestClusterInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt32sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt32sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt32sAttribute", writeTestClusterInt32sAttributeInteractionInfo); + Map writeTestClusterInt40sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint40sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt40sCommandParams.put("value", testClusterint40sCommandParameterInfo); + InteractionInfo writeTestClusterInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt40sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt40sAttribute", writeTestClusterInt40sAttributeInteractionInfo); + Map writeTestClusterInt48sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint48sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt48sCommandParams.put("value", testClusterint48sCommandParameterInfo); + InteractionInfo writeTestClusterInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt48sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt48sAttribute", writeTestClusterInt48sAttributeInteractionInfo); + Map writeTestClusterInt56sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint56sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt56sCommandParams.put("value", testClusterint56sCommandParameterInfo); + InteractionInfo writeTestClusterInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt56sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt56sAttribute", writeTestClusterInt56sAttributeInteractionInfo); + Map writeTestClusterInt64sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint64sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt64sCommandParams.put("value", testClusterint64sCommandParameterInfo); + InteractionInfo writeTestClusterInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt64sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt64sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt64sAttribute", writeTestClusterInt64sAttributeInteractionInfo); + Map writeTestClusterEnum8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterenum8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterEnum8CommandParams.put("value", testClusterenum8CommandParameterInfo); + InteractionInfo writeTestClusterEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEnum8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnum8CommandParams); + writeTestClusterInteractionInfo.put( + "writeEnum8Attribute", writeTestClusterEnum8AttributeInteractionInfo); + Map writeTestClusterEnum16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterenum16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterEnum16CommandParams.put("value", testClusterenum16CommandParameterInfo); + InteractionInfo writeTestClusterEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEnum16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnum16CommandParams); + writeTestClusterInteractionInfo.put( + "writeEnum16Attribute", writeTestClusterEnum16AttributeInteractionInfo); + Map writeTestClusterFloatSingleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterfloatSingleCommandParameterInfo = + new CommandParameterInfo("value", Float.class); + writeTestClusterFloatSingleCommandParams.put( + "value", testClusterfloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeFloatSingleAttribute( + (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatSingleCommandParams); + writeTestClusterInteractionInfo.put( + "writeFloatSingleAttribute", writeTestClusterFloatSingleAttributeInteractionInfo); + Map writeTestClusterFloatDoubleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterfloatDoubleCommandParameterInfo = + new CommandParameterInfo("value", Double.class); + writeTestClusterFloatDoubleCommandParams.put( + "value", testClusterfloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeFloatDoubleAttribute( + (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatDoubleCommandParams); + writeTestClusterInteractionInfo.put( + "writeFloatDoubleAttribute", writeTestClusterFloatDoubleAttributeInteractionInfo); + Map writeTestClusterOctetStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusteroctetStringCommandParameterInfo = + new CommandParameterInfo("value", byte[].class); + writeTestClusterOctetStringCommandParams.put( + "value", testClusteroctetStringCommandParameterInfo); + InteractionInfo writeTestClusterOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterOctetStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeOctetStringAttribute", writeTestClusterOctetStringAttributeInteractionInfo); + Map writeTestClusterLongOctetStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterlongOctetStringCommandParameterInfo = + new CommandParameterInfo("value", byte[].class); + writeTestClusterLongOctetStringCommandParams.put( + "value", testClusterlongOctetStringCommandParameterInfo); + InteractionInfo writeTestClusterLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeLongOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterLongOctetStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeLongOctetStringAttribute", writeTestClusterLongOctetStringAttributeInteractionInfo); + Map writeTestClusterCharStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustercharStringCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeTestClusterCharStringCommandParams.put("value", testClustercharStringCommandParameterInfo); + InteractionInfo writeTestClusterCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterCharStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeCharStringAttribute", writeTestClusterCharStringAttributeInteractionInfo); + Map writeTestClusterLongCharStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterlongCharStringCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeTestClusterLongCharStringCommandParams.put( + "value", testClusterlongCharStringCommandParameterInfo); + InteractionInfo writeTestClusterLongCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeLongCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterLongCharStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeLongCharStringAttribute", writeTestClusterLongCharStringAttributeInteractionInfo); + Map writeTestClusterEpochUsCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterepochUsCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterEpochUsCommandParams.put("value", testClusterepochUsCommandParameterInfo); + InteractionInfo writeTestClusterEpochUsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEpochUsAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEpochUsCommandParams); + writeTestClusterInteractionInfo.put( + "writeEpochUsAttribute", writeTestClusterEpochUsAttributeInteractionInfo); + Map writeTestClusterEpochSCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterepochSCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterEpochSCommandParams.put("value", testClusterepochSCommandParameterInfo); + InteractionInfo writeTestClusterEpochSAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEpochSAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEpochSCommandParams); + writeTestClusterInteractionInfo.put( + "writeEpochSAttribute", writeTestClusterEpochSAttributeInteractionInfo); + Map writeTestClusterVendorIdCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustervendorIdCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterVendorIdCommandParams.put("value", testClustervendorIdCommandParameterInfo); + InteractionInfo writeTestClusterVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeVendorIdAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterVendorIdCommandParams); + writeTestClusterInteractionInfo.put( + "writeVendorIdAttribute", writeTestClusterVendorIdAttributeInteractionInfo); + Map writeTestClusterEnumAttrCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterenumAttrCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterEnumAttrCommandParams.put("value", testClusterenumAttrCommandParameterInfo); + InteractionInfo writeTestClusterEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEnumAttrAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnumAttrCommandParams); + writeTestClusterInteractionInfo.put( + "writeEnumAttrAttribute", writeTestClusterEnumAttrAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt8uCommandParams.put( + "value", testClusterrangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt8uAttribute", + writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt8sCommandParams.put( + "value", testClusterrangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt8sAttribute", + writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt16uCommandParams.put( + "value", testClusterrangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt16uAttribute", + writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt16sCommandParams.put( + "value", testClusterrangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt16sAttribute", + writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo); + Map writeTestClusterTimedWriteBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertimedWriteBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterTimedWriteBooleanCommandParams.put( + "value", testClustertimedWriteBooleanCommandParameterInfo); + InteractionInfo writeTestClusterTimedWriteBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeTimedWriteBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value"), + 10000); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterTimedWriteBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeTimedWriteBooleanAttribute", + writeTestClusterTimedWriteBooleanAttributeInteractionInfo); + Map writeTestClusterGeneralErrorBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustergeneralErrorBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterGeneralErrorBooleanCommandParams.put( + "value", testClustergeneralErrorBooleanCommandParameterInfo); + InteractionInfo writeTestClusterGeneralErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeGeneralErrorBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterGeneralErrorBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeGeneralErrorBooleanAttribute", + writeTestClusterGeneralErrorBooleanAttributeInteractionInfo); + Map writeTestClusterClusterErrorBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterclusterErrorBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterClusterErrorBooleanCommandParams.put( + "value", testClusterclusterErrorBooleanCommandParameterInfo); + InteractionInfo writeTestClusterClusterErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeClusterErrorBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterClusterErrorBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeClusterErrorBooleanAttribute", + writeTestClusterClusterErrorBooleanAttributeInteractionInfo); + Map writeTestClusterUnsupportedCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterunsupportedCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterUnsupportedCommandParams.put( + "value", testClusterunsupportedCommandParameterInfo); + InteractionInfo writeTestClusterUnsupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeUnsupportedAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterUnsupportedCommandParams); + writeTestClusterInteractionInfo.put( + "writeUnsupportedAttribute", writeTestClusterUnsupportedAttributeInteractionInfo); + Map writeTestClusterNullableBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterNullableBooleanCommandParams.put( + "value", testClusternullableBooleanCommandParameterInfo); + InteractionInfo writeTestClusterNullableBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBooleanAttribute", writeTestClusterNullableBooleanAttributeInteractionInfo); + Map writeTestClusterNullableBitmap8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableBitmap8CommandParams.put( + "value", testClusternullableBitmap8CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap8CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap8Attribute", writeTestClusterNullableBitmap8AttributeInteractionInfo); + Map writeTestClusterNullableBitmap16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableBitmap16CommandParams.put( + "value", testClusternullableBitmap16CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap16CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap16Attribute", writeTestClusterNullableBitmap16AttributeInteractionInfo); + Map writeTestClusterNullableBitmap32CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap32CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableBitmap32CommandParams.put( + "value", testClusternullableBitmap32CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap32Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap32CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap32Attribute", writeTestClusterNullableBitmap32AttributeInteractionInfo); + Map writeTestClusterNullableBitmap64CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap64CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableBitmap64CommandParams.put( + "value", testClusternullableBitmap64CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap64Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap64CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap64Attribute", writeTestClusterNullableBitmap64AttributeInteractionInfo); + Map writeTestClusterNullableInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt8uCommandParams.put( + "value", testClusternullableInt8uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt8uAttribute", writeTestClusterNullableInt8uAttributeInteractionInfo); + Map writeTestClusterNullableInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt16uCommandParams.put( + "value", testClusternullableInt16uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt16uAttribute", writeTestClusterNullableInt16uAttributeInteractionInfo); + Map writeTestClusterNullableInt24uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt24uCommandParams.put( + "value", testClusternullableInt24uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt24uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt24uAttribute", writeTestClusterNullableInt24uAttributeInteractionInfo); + Map writeTestClusterNullableInt32uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt32uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt32uCommandParams.put( + "value", testClusternullableInt32uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt32uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt32uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt32uAttribute", writeTestClusterNullableInt32uAttributeInteractionInfo); + Map writeTestClusterNullableInt40uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt40uCommandParams.put( + "value", testClusternullableInt40uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt40uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt40uAttribute", writeTestClusterNullableInt40uAttributeInteractionInfo); + Map writeTestClusterNullableInt48uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt48uCommandParams.put( + "value", testClusternullableInt48uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt48uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt48uAttribute", writeTestClusterNullableInt48uAttributeInteractionInfo); + Map writeTestClusterNullableInt56uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt56uCommandParams.put( + "value", testClusternullableInt56uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt56uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt56uAttribute", writeTestClusterNullableInt56uAttributeInteractionInfo); + Map writeTestClusterNullableInt64uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt64uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt64uCommandParams.put( + "value", testClusternullableInt64uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt64uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt64uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt64uAttribute", writeTestClusterNullableInt64uAttributeInteractionInfo); + Map writeTestClusterNullableInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt8sCommandParams.put( + "value", testClusternullableInt8sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt8sAttribute", writeTestClusterNullableInt8sAttributeInteractionInfo); + Map writeTestClusterNullableInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt16sCommandParams.put( + "value", testClusternullableInt16sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt16sAttribute", writeTestClusterNullableInt16sAttributeInteractionInfo); + Map writeTestClusterNullableInt24sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt24sCommandParams.put( + "value", testClusternullableInt24sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt24sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt24sAttribute", writeTestClusterNullableInt24sAttributeInteractionInfo); + Map writeTestClusterNullableInt32sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt32sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt32sCommandParams.put( + "value", testClusternullableInt32sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt32sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt32sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt32sAttribute", writeTestClusterNullableInt32sAttributeInteractionInfo); + Map writeTestClusterNullableInt40sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt40sCommandParams.put( + "value", testClusternullableInt40sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt40sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt40sAttribute", writeTestClusterNullableInt40sAttributeInteractionInfo); + Map writeTestClusterNullableInt48sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt48sCommandParams.put( + "value", testClusternullableInt48sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt48sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt48sAttribute", writeTestClusterNullableInt48sAttributeInteractionInfo); + Map writeTestClusterNullableInt56sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt56sCommandParams.put( + "value", testClusternullableInt56sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt56sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt56sAttribute", writeTestClusterNullableInt56sAttributeInteractionInfo); + Map writeTestClusterNullableInt64sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt64sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt64sCommandParams.put( + "value", testClusternullableInt64sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt64sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt64sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt64sAttribute", writeTestClusterNullableInt64sAttributeInteractionInfo); + Map writeTestClusterNullableEnum8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableEnum8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnum8CommandParams.put( + "value", testClusternullableEnum8CommandParameterInfo); + InteractionInfo writeTestClusterNullableEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableEnum8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnum8CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableEnum8Attribute", writeTestClusterNullableEnum8AttributeInteractionInfo); + Map writeTestClusterNullableEnum16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableEnum16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnum16CommandParams.put( + "value", testClusternullableEnum16CommandParameterInfo); + InteractionInfo writeTestClusterNullableEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableEnum16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnum16CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableEnum16Attribute", writeTestClusterNullableEnum16AttributeInteractionInfo); + Map writeTestClusterNullableFloatSingleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatSingleCommandParameterInfo = + new CommandParameterInfo("value", Float.class); + writeTestClusterNullableFloatSingleCommandParams.put( + "value", testClusternullableFloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableFloatSingleAttribute( + (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatSingleCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableFloatSingleAttribute", + writeTestClusterNullableFloatSingleAttributeInteractionInfo); + Map writeTestClusterNullableFloatDoubleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatDoubleCommandParameterInfo = + new CommandParameterInfo("value", Double.class); + writeTestClusterNullableFloatDoubleCommandParams.put( + "value", testClusternullableFloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableFloatDoubleAttribute( + (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatDoubleCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableFloatDoubleAttribute", + writeTestClusterNullableFloatDoubleAttributeInteractionInfo); + Map writeTestClusterNullableOctetStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableOctetStringCommandParameterInfo = + new CommandParameterInfo("value", byte[].class); + writeTestClusterNullableOctetStringCommandParams.put( + "value", testClusternullableOctetStringCommandParameterInfo); + InteractionInfo writeTestClusterNullableOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableOctetStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableOctetStringAttribute", + writeTestClusterNullableOctetStringAttributeInteractionInfo); + Map writeTestClusterNullableCharStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableCharStringCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeTestClusterNullableCharStringCommandParams.put( + "value", testClusternullableCharStringCommandParameterInfo); + InteractionInfo writeTestClusterNullableCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableCharStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableCharStringAttribute", + writeTestClusterNullableCharStringAttributeInteractionInfo); + Map writeTestClusterNullableEnumAttrCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableEnumAttrCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnumAttrCommandParams.put( + "value", testClusternullableEnumAttrCommandParameterInfo); + InteractionInfo writeTestClusterNullableEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableEnumAttrAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnumAttrCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableEnumAttrAttribute", writeTestClusterNullableEnumAttrAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt8uCommandParams.put( + "value", testClusternullableRangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt8uAttribute", + writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt8sCommandParams.put( + "value", testClusternullableRangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt8sAttribute", + writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt16uCommandParams.put( + "value", testClusternullableRangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt16uAttribute", + writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt16sCommandParams.put( + "value", testClusternullableRangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt16sAttribute", + writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); + writeAttributeMap.put("testCluster", writeTestClusterInteractionInfo); + Map writeThermostatInteractionInfo = new LinkedHashMap<>(); + Map writeThermostatOccupiedCoolingSetpointCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = + new CommandParameterInfo("value", 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 writeThermostatMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = + new CommandParameterInfo("value", 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 writeThermostatControlSequenceOfOperationCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatsystemModeCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); + Map writeThermostatUserInterfaceConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map + writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo + thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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); + Map writeThreadNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); + Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); + Map writeTimeFormatLocalizationHourFormatCommandParams = + new LinkedHashMap(); + CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); + Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); + Map writeUnitLocalizationTemperatureUnitCommandParams = + new LinkedHashMap(); + CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); + Map writeUserLabelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("userLabel", writeUserLabelInteractionInfo); + Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); + Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); + Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); + Map writeWindowCoveringModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringmodeCommandParameterInfo = + new CommandParameterInfo("value", 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); return writeAttributeMap; } } From bf52c955bda9e06b946e214f7835f0e0b110eb4e Mon Sep 17 00:00:00 2001 From: Seth Rickard Date: Mon, 31 Jan 2022 20:57:46 +0000 Subject: [PATCH 08/14] update zap generated files --- .../chip/devicecontroller/ChipClusters.java | 23283 ++++++++-------- .../chip/devicecontroller/ChipStructs.java | 4075 +-- .../devicecontroller/ClusterInfoMapping.java | 16453 +++++------ .../devicecontroller/ClusterReadMapping.java | 16099 ++++++----- .../devicecontroller/ClusterWriteMapping.java | 4747 ++-- .../zap-generated/CHIPClientCallbacks.cpp | 174 - .../lock-app/zap-generated/CHIPClusters.cpp | 188 - .../lock-app/zap-generated/CHIPClusters.h | 0 .../lock-app/zap-generated/gen_tokens.h | 0 9 files changed, 30921 insertions(+), 34098 deletions(-) delete mode 100755 zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.cpp delete mode 100755 zzz_generated/lock-app/zap-generated/CHIPClusters.cpp mode change 100755 => 100644 zzz_generated/lock-app/zap-generated/CHIPClusters.h mode change 100755 => 100644 zzz_generated/lock-app/zap-generated/gen_tokens.h diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index 5d633d4dab05af..bad2cfd7e68797 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -21,6 +21,7 @@ import androidx.annotation.Nullable; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.Optional; @@ -28,69 +29,54 @@ public class ChipClusters { public interface DefaultClusterCallback { void onSuccess(); - void onError(Exception error); } public interface CharStringAttributeCallback { /** Indicates a successful read for a CHAR_STRING attribute. */ void onSuccess(String value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface OctetStringAttributeCallback { /** Indicates a successful read for an OCTET_STRING attribute. */ void onSuccess(byte[] value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface IntegerAttributeCallback { void onSuccess(int value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface LongAttributeCallback { void onSuccess(long value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface BooleanAttributeCallback { void onSuccess(boolean value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface FloatAttributeCallback { void onSuccess(float value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface DoubleAttributeCallback { void onSuccess(double value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } - public abstract static class BaseChipCluster { + public static abstract class BaseChipCluster { protected long chipClusterPtr; public BaseChipCluster(long devicePtr, int endpointId) { @@ -100,7 +86,7 @@ public BaseChipCluster(long devicePtr, int endpointId) { public abstract long initWithDevice(long devicePtr, int endpointId); public native void deleteCluster(long chipClusterPtr); - + @SuppressWarnings("deprecation") protected void finalize() throws Throwable { super.finalize(); @@ -122,129 +108,115 @@ public AccessControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AclAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ExtensionAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AclAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ExtensionAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAclAttribute(AclAttributeCallback callback) { + public void readAclAttribute( + AclAttributeCallback callback + ) { readAclAttribute(chipClusterPtr, callback); } - - public void writeAclAttribute( - DefaultClusterCallback callback, - ArrayList value) { + public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value) { writeAclAttribute(chipClusterPtr, callback, value, null); } - public void writeAclAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { + public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeAclAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeAclAttribute( - AclAttributeCallback callback, int minInterval, int maxInterval) { + AclAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAclAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readExtensionAttribute(ExtensionAttributeCallback callback) { + public void readExtensionAttribute( + ExtensionAttributeCallback callback + ) { readExtensionAttribute(chipClusterPtr, callback); } - - public void writeExtensionAttribute( - DefaultClusterCallback callback, - ArrayList value) { + public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value) { writeExtensionAttribute(chipClusterPtr, callback, value, null); } - public void writeExtensionAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { + public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeExtensionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeExtensionAttribute( - ExtensionAttributeCallback callback, int minInterval, int maxInterval) { + ExtensionAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeExtensionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAclAttribute(long chipClusterPtr, AclAttributeCallback callback); - - private native void writeAclAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeAclAttribute( - long chipClusterPtr, AclAttributeCallback callback, int minInterval, int maxInterval); - - private native void readExtensionAttribute( - long chipClusterPtr, ExtensionAttributeCallback callback); - - private native void writeExtensionAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeExtensionAttribute( - long chipClusterPtr, ExtensionAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readAclAttribute(long chipClusterPtr, + AclAttributeCallback callback + ); + + private native void writeAclAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeAclAttribute(long chipClusterPtr, + AclAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readExtensionAttribute(long chipClusterPtr, + ExtensionAttributeCallback callback + ); + + private native void writeExtensionAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeExtensionAttribute(long chipClusterPtr, + ExtensionAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class AccountLoginCluster extends BaseChipCluster { @@ -257,90 +229,85 @@ public AccountLoginCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void getSetupPINRequest( - GetSetupPINResponseCallback callback, - String tempAccountIdentifier, - int timedInvokeTimeoutMs) { + + public void getSetupPINRequest(GetSetupPINResponseCallback callback + , String tempAccountIdentifier + , int timedInvokeTimeoutMs) { getSetupPINRequest(chipClusterPtr, callback, tempAccountIdentifier, timedInvokeTimeoutMs); } - public void loginRequest( - DefaultClusterCallback callback, - String tempAccountIdentifier, - String setupPIN, - int timedInvokeTimeoutMs) { + + public void loginRequest(DefaultClusterCallback callback + , String tempAccountIdentifier, String setupPIN + , int timedInvokeTimeoutMs) { loginRequest(chipClusterPtr, callback, tempAccountIdentifier, setupPIN, timedInvokeTimeoutMs); } - public void logoutRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + public void logoutRequest(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { logoutRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - - private native void getSetupPINRequest( - long chipClusterPtr, - GetSetupPINResponseCallback Callback, - String tempAccountIdentifier, - @Nullable Integer timedInvokeTimeoutMs); - - private native void loginRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - String tempAccountIdentifier, - String setupPIN, - @Nullable Integer timedInvokeTimeoutMs); - - private native void logoutRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - + private native void getSetupPINRequest(long chipClusterPtr, GetSetupPINResponseCallback Callback + , String tempAccountIdentifier + , @Nullable Integer timedInvokeTimeoutMs); + private native void loginRequest(long chipClusterPtr, DefaultClusterCallback Callback + , String tempAccountIdentifier, String setupPIN + , @Nullable Integer timedInvokeTimeoutMs); + private native void logoutRequest(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); public interface GetSetupPINResponseCallback { void onSuccess(String setupPIN); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 AdministratorCommissioningCluster extends BaseChipCluster { @@ -353,156 +320,141 @@ public AdministratorCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void openBasicCommissioningWindow( - DefaultClusterCallback callback, Integer commissioningTimeout, int timedInvokeTimeoutMs) { - openBasicCommissioningWindow( - chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs); - } - - public void openCommissioningWindow( - DefaultClusterCallback callback, - Integer commissioningTimeout, - byte[] PAKEVerifier, - Integer discriminator, - Long iterations, - byte[] salt, - Integer passcodeID, - int timedInvokeTimeoutMs) { - openCommissioningWindow( - chipClusterPtr, - callback, - commissioningTimeout, - PAKEVerifier, - discriminator, - iterations, - salt, - passcodeID, - timedInvokeTimeoutMs); - } - - public void revokeCommissioning(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); + public void openBasicCommissioningWindow(DefaultClusterCallback callback + , Integer commissioningTimeout + , int timedInvokeTimeoutMs) { + openBasicCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs); } - private native void openBasicCommissioningWindow( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer commissioningTimeout, - @Nullable Integer timedInvokeTimeoutMs); - - private native void openCommissioningWindow( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer commissioningTimeout, - byte[] PAKEVerifier, - Integer discriminator, - Long iterations, - byte[] salt, - Integer passcodeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void revokeCommissioning( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AdminFabricIndexAttributeCallback { - void onSuccess(Integer value); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} + public void openCommissioningWindow(DefaultClusterCallback callback + , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID + , int timedInvokeTimeoutMs) { + openCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, PAKEVerifier, discriminator, iterations, salt, passcodeID, timedInvokeTimeoutMs); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void revokeCommissioning(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void openBasicCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback + , Integer commissioningTimeout + , @Nullable Integer timedInvokeTimeoutMs); + private native void openCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback + , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void revokeCommissioning(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface AdminFabricIndexAttributeCallback { + void onSuccess( Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readWindowStatusAttribute(IntegerAttributeCallback callback) { + public void readWindowStatusAttribute( + IntegerAttributeCallback callback + ) { readWindowStatusAttribute(chipClusterPtr, callback); } - public void subscribeWindowStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWindowStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAdminFabricIndexAttribute(AdminFabricIndexAttributeCallback callback) { + public void readAdminFabricIndexAttribute( + AdminFabricIndexAttributeCallback callback + ) { readAdminFabricIndexAttribute(chipClusterPtr, callback); } - public void subscribeAdminFabricIndexAttribute( - AdminFabricIndexAttributeCallback callback, int minInterval, int maxInterval) { + AdminFabricIndexAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAdminFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAdminVendorIdAttribute(IntegerAttributeCallback callback) { + public void readAdminVendorIdAttribute( + IntegerAttributeCallback callback + ) { readAdminVendorIdAttribute(chipClusterPtr, callback); } - public void subscribeAdminVendorIdAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAdminVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readWindowStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeWindowStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAdminFabricIndexAttribute( - long chipClusterPtr, AdminFabricIndexAttributeCallback callback); - - private native void subscribeAdminFabricIndexAttribute( - long chipClusterPtr, - AdminFabricIndexAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readAdminVendorIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAdminVendorIdAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readWindowStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeWindowStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAdminFabricIndexAttribute(long chipClusterPtr, + AdminFabricIndexAttributeCallback callback + ); + private native void subscribeAdminFabricIndexAttribute(long chipClusterPtr, + AdminFabricIndexAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAdminVendorIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAdminVendorIdAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ApplicationBasicCluster extends BaseChipCluster { @@ -515,171 +467,187 @@ public ApplicationBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AllowedVendorListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AllowedVendorListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readVendorNameAttribute(CharStringAttributeCallback callback) { + public void readVendorNameAttribute( + CharStringAttributeCallback callback + ) { readVendorNameAttribute(chipClusterPtr, callback); } - public void subscribeVendorNameAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIdAttribute(IntegerAttributeCallback callback) { + public void readVendorIdAttribute( + IntegerAttributeCallback callback + ) { readVendorIdAttribute(chipClusterPtr, callback); } - public void subscribeVendorIdAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationNameAttribute(CharStringAttributeCallback callback) { + public void readApplicationNameAttribute( + CharStringAttributeCallback callback + ) { readApplicationNameAttribute(chipClusterPtr, callback); } - public void subscribeApplicationNameAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeApplicationNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductIdAttribute(IntegerAttributeCallback callback) { + public void readProductIdAttribute( + IntegerAttributeCallback callback + ) { readProductIdAttribute(chipClusterPtr, callback); } - public void subscribeProductIdAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeProductIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationStatusAttribute(IntegerAttributeCallback callback) { + public void readApplicationStatusAttribute( + IntegerAttributeCallback callback + ) { readApplicationStatusAttribute(chipClusterPtr, callback); } - public void subscribeApplicationStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeApplicationStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationVersionAttribute(CharStringAttributeCallback callback) { + public void readApplicationVersionAttribute( + CharStringAttributeCallback callback + ) { readApplicationVersionAttribute(chipClusterPtr, callback); } - public void subscribeApplicationVersionAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeApplicationVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAllowedVendorListAttribute(AllowedVendorListAttributeCallback callback) { + public void readAllowedVendorListAttribute( + AllowedVendorListAttributeCallback callback + ) { readAllowedVendorListAttribute(chipClusterPtr, callback); } - public void subscribeAllowedVendorListAttribute( - AllowedVendorListAttributeCallback callback, int minInterval, int maxInterval) { + AllowedVendorListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAllowedVendorListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readVendorNameAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeVendorNameAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readVendorIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeVendorIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readApplicationNameAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeApplicationNameAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readProductIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeProductIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readApplicationStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeApplicationStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readApplicationVersionAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeApplicationVersionAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readAllowedVendorListAttribute( - long chipClusterPtr, AllowedVendorListAttributeCallback callback); - - private native void subscribeAllowedVendorListAttribute( - long chipClusterPtr, - AllowedVendorListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeVendorIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApplicationNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeApplicationNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeProductIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApplicationStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeApplicationStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApplicationVersionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeApplicationVersionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAllowedVendorListAttribute(long chipClusterPtr, + AllowedVendorListAttributeCallback callback + ); + private native void subscribeAllowedVendorListAttribute(long chipClusterPtr, + AllowedVendorListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ApplicationLauncherCluster extends BaseChipCluster { @@ -692,139 +660,121 @@ public ApplicationLauncherCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void hideAppRequest( - LauncherResponseCallback callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void hideAppRequest(LauncherResponseCallback callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { hideAppRequest(chipClusterPtr, callback, application, null); } - public void hideAppRequest( - LauncherResponseCallback callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - int timedInvokeTimeoutMs) { + public void hideAppRequest(LauncherResponseCallback callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , int timedInvokeTimeoutMs) { hideAppRequest(chipClusterPtr, callback, application, timedInvokeTimeoutMs); } - public void launchAppRequest( - LauncherResponseCallback callback, - String data, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void launchAppRequest(LauncherResponseCallback callback + , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { launchAppRequest(chipClusterPtr, callback, data, application, null); } - public void launchAppRequest( - LauncherResponseCallback callback, - String data, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - int timedInvokeTimeoutMs) { + public void launchAppRequest(LauncherResponseCallback callback + , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , int timedInvokeTimeoutMs) { launchAppRequest(chipClusterPtr, callback, data, application, timedInvokeTimeoutMs); } - public void stopAppRequest( - LauncherResponseCallback callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void stopAppRequest(LauncherResponseCallback callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { stopAppRequest(chipClusterPtr, callback, application, null); } - public void stopAppRequest( - LauncherResponseCallback callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - int timedInvokeTimeoutMs) { + public void stopAppRequest(LauncherResponseCallback callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , int timedInvokeTimeoutMs) { stopAppRequest(chipClusterPtr, callback, application, timedInvokeTimeoutMs); } - - private native void hideAppRequest( - long chipClusterPtr, - LauncherResponseCallback Callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - @Nullable Integer timedInvokeTimeoutMs); - - private native void launchAppRequest( - long chipClusterPtr, - LauncherResponseCallback Callback, - String data, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopAppRequest( - long chipClusterPtr, - LauncherResponseCallback Callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - @Nullable Integer timedInvokeTimeoutMs); - + private native void hideAppRequest(long chipClusterPtr, LauncherResponseCallback Callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , @Nullable Integer timedInvokeTimeoutMs); + private native void launchAppRequest(long chipClusterPtr, LauncherResponseCallback Callback + , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopAppRequest(long chipClusterPtr, LauncherResponseCallback Callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , @Nullable Integer timedInvokeTimeoutMs); public interface LauncherResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } - public interface ApplicationLauncherListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface ApplicationLauncherListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } public void readApplicationLauncherListAttribute( - ApplicationLauncherListAttributeCallback callback) { + ApplicationLauncherListAttributeCallback callback + ) { readApplicationLauncherListAttribute(chipClusterPtr, callback); } - public void subscribeApplicationLauncherListAttribute( - ApplicationLauncherListAttributeCallback callback, int minInterval, int maxInterval) { + ApplicationLauncherListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeApplicationLauncherListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readApplicationLauncherListAttribute( - long chipClusterPtr, ApplicationLauncherListAttributeCallback callback); - - private native void subscribeApplicationLauncherListAttribute( - long chipClusterPtr, - ApplicationLauncherListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readApplicationLauncherListAttribute(long chipClusterPtr, + ApplicationLauncherListAttributeCallback callback + ); + private native void subscribeApplicationLauncherListAttribute(long chipClusterPtr, + ApplicationLauncherListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class AudioOutputCluster extends BaseChipCluster { @@ -837,118 +787,120 @@ public AudioOutputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void renameOutputRequest(DefaultClusterCallback callback, Integer index, String name) { + public void renameOutputRequest(DefaultClusterCallback callback + , Integer index, String name) { renameOutputRequest(chipClusterPtr, callback, index, name, null); } - public void renameOutputRequest( - DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) { + public void renameOutputRequest(DefaultClusterCallback callback + , Integer index, String name + , int timedInvokeTimeoutMs) { renameOutputRequest(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); } - public void selectOutputRequest(DefaultClusterCallback callback, Integer index) { + public void selectOutputRequest(DefaultClusterCallback callback + , Integer index) { selectOutputRequest(chipClusterPtr, callback, index, null); } - public void selectOutputRequest( - DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) { + public void selectOutputRequest(DefaultClusterCallback callback + , Integer index + , int timedInvokeTimeoutMs) { selectOutputRequest(chipClusterPtr, callback, index, timedInvokeTimeoutMs); } + private native void renameOutputRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index, String name + , @Nullable Integer timedInvokeTimeoutMs); + private native void selectOutputRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index + , @Nullable Integer timedInvokeTimeoutMs); + + public interface AudioOutputListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void renameOutputRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer index, - String name, - @Nullable Integer timedInvokeTimeoutMs); - - private native void selectOutputRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer index, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AudioOutputListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readAudioOutputListAttribute(AudioOutputListAttributeCallback callback) { + public void readAudioOutputListAttribute( + AudioOutputListAttributeCallback callback + ) { readAudioOutputListAttribute(chipClusterPtr, callback); } - public void subscribeAudioOutputListAttribute( - AudioOutputListAttributeCallback callback, int minInterval, int maxInterval) { + AudioOutputListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAudioOutputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentAudioOutputAttribute(IntegerAttributeCallback callback) { + public void readCurrentAudioOutputAttribute( + IntegerAttributeCallback callback + ) { readCurrentAudioOutputAttribute(chipClusterPtr, callback); } - public void subscribeCurrentAudioOutputAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentAudioOutputAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAudioOutputListAttribute( - long chipClusterPtr, AudioOutputListAttributeCallback callback); - - private native void subscribeAudioOutputListAttribute( - long chipClusterPtr, - AudioOutputListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentAudioOutputAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentAudioOutputAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readAudioOutputListAttribute(long chipClusterPtr, + AudioOutputListAttributeCallback callback + ); + private native void subscribeAudioOutputListAttribute(long chipClusterPtr, + AudioOutputListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentAudioOutputAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentAudioOutputAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BarrierControlCluster extends BaseChipCluster { @@ -961,135 +913,153 @@ public BarrierControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void barrierControlGoToPercent(DefaultClusterCallback callback, Integer percentOpen) { + public void barrierControlGoToPercent(DefaultClusterCallback callback + , Integer percentOpen) { barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, null); } - public void barrierControlGoToPercent( - DefaultClusterCallback callback, Integer percentOpen, int timedInvokeTimeoutMs) { + public void barrierControlGoToPercent(DefaultClusterCallback callback + , Integer percentOpen + , int timedInvokeTimeoutMs) { barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, timedInvokeTimeoutMs); } - public void barrierControlStop(DefaultClusterCallback callback) { + public void barrierControlStop(DefaultClusterCallback callback + ) { barrierControlStop(chipClusterPtr, callback, null); } - public void barrierControlStop(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void barrierControlStop(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { barrierControlStop(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void barrierControlGoToPercent(long chipClusterPtr, DefaultClusterCallback Callback + , Integer percentOpen + , @Nullable Integer timedInvokeTimeoutMs); + private native void barrierControlStop(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void barrierControlGoToPercent( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer percentOpen, - @Nullable Integer timedInvokeTimeoutMs); - - private native void barrierControlStop( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readBarrierMovingStateAttribute(IntegerAttributeCallback callback) { + public void readBarrierMovingStateAttribute( + IntegerAttributeCallback callback + ) { readBarrierMovingStateAttribute(chipClusterPtr, callback); } - public void subscribeBarrierMovingStateAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBarrierMovingStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierSafetyStatusAttribute(IntegerAttributeCallback callback) { + public void readBarrierSafetyStatusAttribute( + IntegerAttributeCallback callback + ) { readBarrierSafetyStatusAttribute(chipClusterPtr, callback); } - public void subscribeBarrierSafetyStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBarrierSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierCapabilitiesAttribute(IntegerAttributeCallback callback) { + public void readBarrierCapabilitiesAttribute( + IntegerAttributeCallback callback + ) { readBarrierCapabilitiesAttribute(chipClusterPtr, callback); } - public void subscribeBarrierCapabilitiesAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBarrierCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierPositionAttribute(IntegerAttributeCallback callback) { + public void readBarrierPositionAttribute( + IntegerAttributeCallback callback + ) { readBarrierPositionAttribute(chipClusterPtr, callback); } - public void subscribeBarrierPositionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBarrierPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBarrierMovingStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBarrierMovingStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBarrierSafetyStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBarrierSafetyStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBarrierCapabilitiesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBarrierCapabilitiesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBarrierPositionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBarrierPositionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readBarrierMovingStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierMovingStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BasicCluster extends BaseChipCluster { @@ -1102,420 +1072,442 @@ public BasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface VendorIDAttributeCallback { - void onSuccess(Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface VendorIDAttributeCallback { + void onSuccess( Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readInteractionModelVersionAttribute(IntegerAttributeCallback callback) { + public void readInteractionModelVersionAttribute( + IntegerAttributeCallback callback + ) { readInteractionModelVersionAttribute(chipClusterPtr, callback); } - public void subscribeInteractionModelVersionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInteractionModelVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorNameAttribute(CharStringAttributeCallback callback) { + public void readVendorNameAttribute( + CharStringAttributeCallback callback + ) { readVendorNameAttribute(chipClusterPtr, callback); } - public void subscribeVendorNameAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIDAttribute(VendorIDAttributeCallback callback) { + public void readVendorIDAttribute( + VendorIDAttributeCallback callback + ) { readVendorIDAttribute(chipClusterPtr, callback); } - public void subscribeVendorIDAttribute( - VendorIDAttributeCallback callback, int minInterval, int maxInterval) { + VendorIDAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductNameAttribute(CharStringAttributeCallback callback) { + public void readProductNameAttribute( + CharStringAttributeCallback callback + ) { readProductNameAttribute(chipClusterPtr, callback); } - public void subscribeProductNameAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeProductNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductIDAttribute(IntegerAttributeCallback callback) { + public void readProductIDAttribute( + IntegerAttributeCallback callback + ) { readProductIDAttribute(chipClusterPtr, callback); } - public void subscribeProductIDAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeProductIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNodeLabelAttribute(CharStringAttributeCallback callback) { + public void readNodeLabelAttribute( + CharStringAttributeCallback callback + ) { readNodeLabelAttribute(chipClusterPtr, callback); } - public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value) { writeNodeLabelAttribute(chipClusterPtr, callback, value, null); } - public void writeNodeLabelAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeNodeLabelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNodeLabelAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNodeLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocationAttribute(CharStringAttributeCallback callback) { + public void readLocationAttribute( + CharStringAttributeCallback callback + ) { readLocationAttribute(chipClusterPtr, callback); } - public void writeLocationAttribute(DefaultClusterCallback callback, String value) { writeLocationAttribute(chipClusterPtr, callback, value, null); } - public void writeLocationAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLocationAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLocationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLocationAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLocationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readHardwareVersionAttribute(IntegerAttributeCallback callback) { + public void readHardwareVersionAttribute( + IntegerAttributeCallback callback + ) { readHardwareVersionAttribute(chipClusterPtr, callback); } - public void subscribeHardwareVersionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeHardwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readHardwareVersionStringAttribute(CharStringAttributeCallback callback) { + public void readHardwareVersionStringAttribute( + CharStringAttributeCallback callback + ) { readHardwareVersionStringAttribute(chipClusterPtr, callback); } - public void subscribeHardwareVersionStringAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeHardwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoftwareVersionAttribute(LongAttributeCallback callback) { + public void readSoftwareVersionAttribute( + LongAttributeCallback callback + ) { readSoftwareVersionAttribute(chipClusterPtr, callback); } - public void subscribeSoftwareVersionAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSoftwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoftwareVersionStringAttribute(CharStringAttributeCallback callback) { + public void readSoftwareVersionStringAttribute( + CharStringAttributeCallback callback + ) { readSoftwareVersionStringAttribute(chipClusterPtr, callback); } - public void subscribeSoftwareVersionStringAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSoftwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readManufacturingDateAttribute(CharStringAttributeCallback callback) { + public void readManufacturingDateAttribute( + CharStringAttributeCallback callback + ) { readManufacturingDateAttribute(chipClusterPtr, callback); } - public void subscribeManufacturingDateAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeManufacturingDateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartNumberAttribute(CharStringAttributeCallback callback) { + public void readPartNumberAttribute( + CharStringAttributeCallback callback + ) { readPartNumberAttribute(chipClusterPtr, callback); } - public void subscribePartNumberAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePartNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductURLAttribute(CharStringAttributeCallback callback) { + public void readProductURLAttribute( + CharStringAttributeCallback callback + ) { readProductURLAttribute(chipClusterPtr, callback); } - public void subscribeProductURLAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeProductURLAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductLabelAttribute(CharStringAttributeCallback callback) { + public void readProductLabelAttribute( + CharStringAttributeCallback callback + ) { readProductLabelAttribute(chipClusterPtr, callback); } - public void subscribeProductLabelAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeProductLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSerialNumberAttribute(CharStringAttributeCallback callback) { + public void readSerialNumberAttribute( + CharStringAttributeCallback callback + ) { readSerialNumberAttribute(chipClusterPtr, callback); } - public void subscribeSerialNumberAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSerialNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocalConfigDisabledAttribute(BooleanAttributeCallback callback) { + public void readLocalConfigDisabledAttribute( + BooleanAttributeCallback callback + ) { readLocalConfigDisabledAttribute(chipClusterPtr, callback); } - public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value) { writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, null); } - public void writeLocalConfigDisabledAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLocalConfigDisabledAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLocalConfigDisabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readReachableAttribute(BooleanAttributeCallback callback) { + public void readReachableAttribute( + BooleanAttributeCallback callback + ) { readReachableAttribute(chipClusterPtr, callback); } - public void subscribeReachableAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeReachableAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUniqueIDAttribute(CharStringAttributeCallback callback) { + public void readUniqueIDAttribute( + CharStringAttributeCallback callback + ) { readUniqueIDAttribute(chipClusterPtr, callback); } - public void subscribeUniqueIDAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeUniqueIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readInteractionModelVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeInteractionModelVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readVendorNameAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeVendorNameAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readVendorIDAttribute( - long chipClusterPtr, VendorIDAttributeCallback callback); - - private native void subscribeVendorIDAttribute( - long chipClusterPtr, VendorIDAttributeCallback callback, int minInterval, int maxInterval); - - private native void readProductNameAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeProductNameAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readProductIDAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeProductIDAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNodeLabelAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeNodeLabelAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNodeLabelAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readLocationAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeLocationAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLocationAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readHardwareVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeHardwareVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readHardwareVersionStringAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeHardwareVersionStringAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSoftwareVersionAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeSoftwareVersionAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSoftwareVersionStringAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeSoftwareVersionStringAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readManufacturingDateAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeManufacturingDateAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readPartNumberAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribePartNumberAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readProductURLAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeProductURLAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readProductLabelAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeProductLabelAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSerialNumberAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeSerialNumberAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readLocalConfigDisabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeLocalConfigDisabledAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLocalConfigDisabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readReachableAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeReachableAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readUniqueIDAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeUniqueIDAttribute( - long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readInteractionModelVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInteractionModelVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorIDAttribute(long chipClusterPtr, + VendorIDAttributeCallback callback + ); + private native void subscribeVendorIDAttribute(long chipClusterPtr, + VendorIDAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readProductNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeProductIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNodeLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeNodeLabelAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNodeLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLocationAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeLocationAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLocationAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readHardwareVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeHardwareVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readHardwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeHardwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSoftwareVersionAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSoftwareVersionAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSoftwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeSoftwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readManufacturingDateAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeManufacturingDateAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPartNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribePartNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductURLAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductURLAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSerialNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeSerialNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLocalConfigDisabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeLocalConfigDisabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLocalConfigDisabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readReachableAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeReachableAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUniqueIDAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeUniqueIDAttribute(long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BinaryInputBasicCluster extends BaseChipCluster { @@ -1528,121 +1520,124 @@ public BinaryInputBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readOutOfServiceAttribute(BooleanAttributeCallback callback) { + public void readOutOfServiceAttribute( + BooleanAttributeCallback callback + ) { readOutOfServiceAttribute(chipClusterPtr, callback); } - public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value) { writeOutOfServiceAttribute(chipClusterPtr, callback, value, null); } - public void writeOutOfServiceAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeOutOfServiceAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOutOfServiceAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOutOfServiceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPresentValueAttribute(BooleanAttributeCallback callback) { + public void readPresentValueAttribute( + BooleanAttributeCallback callback + ) { readPresentValueAttribute(chipClusterPtr, callback); } - public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value) { writePresentValueAttribute(chipClusterPtr, callback, value, null); } - public void writePresentValueAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writePresentValueAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribePresentValueAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePresentValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStatusFlagsAttribute(IntegerAttributeCallback callback) { + public void readStatusFlagsAttribute( + IntegerAttributeCallback callback + ) { readStatusFlagsAttribute(chipClusterPtr, callback); } - public void subscribeStatusFlagsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStatusFlagsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOutOfServiceAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeOutOfServiceAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOutOfServiceAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPresentValueAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writePresentValueAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribePresentValueAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStatusFlagsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeStatusFlagsAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readOutOfServiceAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeOutOfServiceAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOutOfServiceAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPresentValueAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writePresentValueAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribePresentValueAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStatusFlagsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStatusFlagsAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BindingCluster extends BaseChipCluster { @@ -1655,103 +1650,77 @@ public BindingCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void bind( - DefaultClusterCallback callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId) { + public void bind(DefaultClusterCallback callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId) { bind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, null); } - public void bind( - DefaultClusterCallback callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId, - int timedInvokeTimeoutMs) { + public void bind(DefaultClusterCallback callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId + , int timedInvokeTimeoutMs) { bind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); } - public void unbind( - DefaultClusterCallback callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId) { + public void unbind(DefaultClusterCallback callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId) { unbind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, null); } - public void unbind( - DefaultClusterCallback callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId, - int timedInvokeTimeoutMs) { - unbind( - chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); + public void unbind(DefaultClusterCallback callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId + , int timedInvokeTimeoutMs) { + unbind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); } + private native void bind(long chipClusterPtr, DefaultClusterCallback Callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId + , @Nullable Integer timedInvokeTimeoutMs); + private native void unbind(long chipClusterPtr, DefaultClusterCallback Callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId + , @Nullable Integer timedInvokeTimeoutMs); - private native void bind( - long chipClusterPtr, - DefaultClusterCallback Callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void unbind( - long chipClusterPtr, - DefaultClusterCallback Callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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); + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BooleanStateCluster extends BaseChipCluster { @@ -1764,61 +1733,68 @@ public BooleanStateCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readStateValueAttribute(BooleanAttributeCallback callback) { + public void readStateValueAttribute( + BooleanAttributeCallback callback + ) { readStateValueAttribute(chipClusterPtr, callback); } - public void subscribeStateValueAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStateValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readStateValueAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeStateValueAttribute( - long chipClusterPtr, BooleanAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readStateValueAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeStateValueAttribute(long chipClusterPtr, + BooleanAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BridgedActionsCluster extends BaseChipCluster { @@ -1831,375 +1807,284 @@ public BridgedActionsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void disableAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void disableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { disableAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void disableAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void disableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { disableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void disableActionWithDuration( - DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { + public void disableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void disableActionWithDuration( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Long duration, - int timedInvokeTimeoutMs) { - disableActionWithDuration( - chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void disableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void enableAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void enableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { enableAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void enableAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void enableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { enableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void enableActionWithDuration( - DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { + public void enableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void enableActionWithDuration( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Long duration, - int timedInvokeTimeoutMs) { - enableActionWithDuration( - chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void enableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void instantAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void instantAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { instantAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void instantAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void instantAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { instantAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void instantActionWithTransition( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Integer transitionTime) { - instantActionWithTransition( - chipClusterPtr, callback, actionID, invokeID, transitionTime, null); + public void instantActionWithTransition(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Integer transitionTime) { + instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, null); } - public void instantActionWithTransition( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Integer transitionTime, - int timedInvokeTimeoutMs) { - instantActionWithTransition( - chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs); + public void instantActionWithTransition(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Integer transitionTime + , int timedInvokeTimeoutMs) { + instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs); } - public void pauseAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void pauseAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { pauseAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void pauseAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void pauseAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { pauseAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void pauseActionWithDuration( - DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { + public void pauseActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void pauseActionWithDuration( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Long duration, - int timedInvokeTimeoutMs) { - pauseActionWithDuration( - chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void pauseActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void resumeAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void resumeAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { resumeAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void resumeAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void resumeAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { resumeAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void startAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void startAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { startAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void startAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void startAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { startAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void startActionWithDuration( - DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { + public void startActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void startActionWithDuration( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Long duration, - int timedInvokeTimeoutMs) { - startActionWithDuration( - chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void startActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void stopAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void stopAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { stopAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void stopAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void stopAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { stopAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } + private native void disableAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void disableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + private native void enableAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void enableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + private native void instantAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void instantActionWithTransition(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Integer transitionTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void pauseAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void pauseActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + private native void resumeAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void startAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void startActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + + public interface ActionListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface EndpointListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void disableAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void disableActionWithDuration( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - Long duration, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enableAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enableActionWithDuration( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - Long duration, - @Nullable Integer timedInvokeTimeoutMs); - - private native void instantAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void instantActionWithTransition( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - Integer transitionTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void pauseAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void pauseActionWithDuration( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - Long duration, - @Nullable Integer timedInvokeTimeoutMs); - - private native void resumeAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void startAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void startActionWithDuration( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - Long duration, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - public interface ActionListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface EndpointListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readActionListAttribute(ActionListAttributeCallback callback) { + public void readActionListAttribute( + ActionListAttributeCallback callback + ) { readActionListAttribute(chipClusterPtr, callback); } - public void subscribeActionListAttribute( - ActionListAttributeCallback callback, int minInterval, int maxInterval) { + ActionListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeActionListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEndpointListAttribute(EndpointListAttributeCallback callback) { + public void readEndpointListAttribute( + EndpointListAttributeCallback callback + ) { readEndpointListAttribute(chipClusterPtr, callback); } - public void subscribeEndpointListAttribute( - EndpointListAttributeCallback callback, int minInterval, int maxInterval) { + EndpointListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeEndpointListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSetupUrlAttribute(CharStringAttributeCallback callback) { + public void readSetupUrlAttribute( + CharStringAttributeCallback callback + ) { readSetupUrlAttribute(chipClusterPtr, callback); } - public void subscribeSetupUrlAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSetupUrlAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readActionListAttribute( - long chipClusterPtr, ActionListAttributeCallback callback); - - private native void subscribeActionListAttribute( - long chipClusterPtr, - ActionListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readEndpointListAttribute( - long chipClusterPtr, EndpointListAttributeCallback callback); - - private native void subscribeEndpointListAttribute( - long chipClusterPtr, - EndpointListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSetupUrlAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeSetupUrlAttribute( - long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readActionListAttribute(long chipClusterPtr, + ActionListAttributeCallback callback + ); + private native void subscribeActionListAttribute(long chipClusterPtr, + ActionListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEndpointListAttribute(long chipClusterPtr, + EndpointListAttributeCallback callback + ); + private native void subscribeEndpointListAttribute(long chipClusterPtr, + EndpointListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSetupUrlAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeSetupUrlAttribute(long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BridgedDeviceBasicCluster extends BaseChipCluster { @@ -2212,46 +2097,49 @@ public BridgedDeviceBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 ChannelCluster extends BaseChipCluster { @@ -2264,129 +2152,121 @@ public ChannelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void changeChannelByNumberRequest( - DefaultClusterCallback callback, Integer majorNumber, Integer minorNumber) { + public void changeChannelByNumberRequest(DefaultClusterCallback callback + , Integer majorNumber, Integer minorNumber) { changeChannelByNumberRequest(chipClusterPtr, callback, majorNumber, minorNumber, null); } - public void changeChannelByNumberRequest( - DefaultClusterCallback callback, - Integer majorNumber, - Integer minorNumber, - int timedInvokeTimeoutMs) { - changeChannelByNumberRequest( - chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs); + public void changeChannelByNumberRequest(DefaultClusterCallback callback + , Integer majorNumber, Integer minorNumber + , int timedInvokeTimeoutMs) { + changeChannelByNumberRequest(chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs); } - public void changeChannelRequest(ChangeChannelResponseCallback callback, String match) { + public void changeChannelRequest(ChangeChannelResponseCallback callback + , String match) { changeChannelRequest(chipClusterPtr, callback, match, null); } - public void changeChannelRequest( - ChangeChannelResponseCallback callback, String match, int timedInvokeTimeoutMs) { + public void changeChannelRequest(ChangeChannelResponseCallback callback + , String match + , int timedInvokeTimeoutMs) { changeChannelRequest(chipClusterPtr, callback, match, timedInvokeTimeoutMs); } - public void skipChannelRequest(DefaultClusterCallback callback, Integer count) { + public void skipChannelRequest(DefaultClusterCallback callback + , Integer count) { skipChannelRequest(chipClusterPtr, callback, count, null); } - public void skipChannelRequest( - DefaultClusterCallback callback, Integer count, int timedInvokeTimeoutMs) { + public void skipChannelRequest(DefaultClusterCallback callback + , Integer count + , int timedInvokeTimeoutMs) { skipChannelRequest(chipClusterPtr, callback, count, timedInvokeTimeoutMs); } - - private native void changeChannelByNumberRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer majorNumber, - Integer minorNumber, - @Nullable Integer timedInvokeTimeoutMs); - - private native void changeChannelRequest( - long chipClusterPtr, - ChangeChannelResponseCallback Callback, - String match, - @Nullable Integer timedInvokeTimeoutMs); - - private native void skipChannelRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer count, - @Nullable Integer timedInvokeTimeoutMs); - + private native void changeChannelByNumberRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer majorNumber, Integer minorNumber + , @Nullable Integer timedInvokeTimeoutMs); + private native void changeChannelRequest(long chipClusterPtr, ChangeChannelResponseCallback Callback + , String match + , @Nullable Integer timedInvokeTimeoutMs); + private native void skipChannelRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer count + , @Nullable Integer timedInvokeTimeoutMs); public interface ChangeChannelResponseCallback { void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType); - + void onError(Exception error); } - public interface ChannelListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface ChannelListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readChannelListAttribute(ChannelListAttributeCallback callback) { + public void readChannelListAttribute( + ChannelListAttributeCallback callback + ) { readChannelListAttribute(chipClusterPtr, callback); } - public void subscribeChannelListAttribute( - ChannelListAttributeCallback callback, int minInterval, int maxInterval) { + ChannelListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeChannelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readChannelListAttribute( - long chipClusterPtr, ChannelListAttributeCallback callback); - - private native void subscribeChannelListAttribute( - long chipClusterPtr, - ChannelListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readChannelListAttribute(long chipClusterPtr, + ChannelListAttributeCallback callback + ); + private native void subscribeChannelListAttribute(long chipClusterPtr, + ChannelListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ColorControlCluster extends BaseChipCluster { @@ -2399,2032 +2279,1562 @@ public ColorControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void colorLoopSet( - DefaultClusterCallback callback, - Integer updateFlags, - Integer action, - Integer direction, - Integer time, - Integer startHue, - Integer optionsMask, - Integer optionsOverride) { - colorLoopSet( - chipClusterPtr, - callback, - updateFlags, - action, - direction, - time, - startHue, - optionsMask, - optionsOverride, - null); - } - - public void colorLoopSet( - DefaultClusterCallback callback, - Integer updateFlags, - Integer action, - Integer direction, - Integer time, - Integer startHue, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - colorLoopSet( - chipClusterPtr, - callback, - updateFlags, - action, - direction, - time, - startHue, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void enhancedMoveHue( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride) { + public void colorLoopSet(DefaultClusterCallback callback + , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride) { + colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, null); + } + + public void colorLoopSet(DefaultClusterCallback callback + , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedMoveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void enhancedMoveHue( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - enhancedMoveHue( - chipClusterPtr, - callback, - moveMode, - rate, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void enhancedMoveToHue( - DefaultClusterCallback callback, - Integer enhancedHue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - enhancedMoveToHue( - chipClusterPtr, - callback, - enhancedHue, - direction, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void enhancedMoveToHue( - DefaultClusterCallback callback, - Integer enhancedHue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - enhancedMoveToHue( - chipClusterPtr, - callback, - enhancedHue, - direction, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void enhancedMoveToHueAndSaturation( - DefaultClusterCallback callback, - Integer enhancedHue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - enhancedMoveToHueAndSaturation( - chipClusterPtr, - callback, - enhancedHue, - saturation, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void enhancedMoveToHueAndSaturation( - DefaultClusterCallback callback, - Integer enhancedHue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - enhancedMoveToHueAndSaturation( - chipClusterPtr, - callback, - enhancedHue, - saturation, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void enhancedStepHue( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - enhancedStepHue( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void enhancedStepHue( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - enhancedStepHue( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveColor( - DefaultClusterCallback callback, - Integer rateX, - Integer rateY, - Integer optionsMask, - Integer optionsOverride) { + public void enhancedMoveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedMoveToHue(DefaultClusterCallback callback + , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, null); + } + + public void enhancedMoveToHue(DefaultClusterCallback callback + , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback + , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback + , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedStepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); + } + + public void enhancedStepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveColor(DefaultClusterCallback callback + , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride) { moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, null); } - public void moveColor( - DefaultClusterCallback callback, - Integer rateX, - Integer rateY, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveColor( - chipClusterPtr, - callback, - rateX, - rateY, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveColorTemperature( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride) { - moveColorTemperature( - chipClusterPtr, - callback, - moveMode, - rate, - colorTemperatureMinimum, - colorTemperatureMaximum, - optionsMask, - optionsOverride, - null); - } - - public void moveColorTemperature( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveColorTemperature( - chipClusterPtr, - callback, - moveMode, - rate, - colorTemperatureMinimum, - colorTemperatureMaximum, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveHue( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride) { + public void moveColor(DefaultClusterCallback callback + , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveColorTemperature(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride) { + moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, null); + } + + public void moveColorTemperature(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void moveHue( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveHue( - chipClusterPtr, - callback, - moveMode, - rate, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveSaturation( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride) { + public void moveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveSaturation(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void moveSaturation( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveSaturation( - chipClusterPtr, - callback, - moveMode, - rate, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveToColor( - DefaultClusterCallback callback, - Integer colorX, - Integer colorY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - moveToColor( - chipClusterPtr, - callback, - colorX, - colorY, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void moveToColor( - DefaultClusterCallback callback, - Integer colorX, - Integer colorY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveToColor( - chipClusterPtr, - callback, - colorX, - colorY, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveToColorTemperature( - DefaultClusterCallback callback, - Integer colorTemperature, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - moveToColorTemperature( - chipClusterPtr, - callback, - colorTemperature, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void moveToColorTemperature( - DefaultClusterCallback callback, - Integer colorTemperature, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveToColorTemperature( - chipClusterPtr, - callback, - colorTemperature, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveToHue( - DefaultClusterCallback callback, - Integer hue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - moveToHue( - chipClusterPtr, - callback, - hue, - direction, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void moveToHue( - DefaultClusterCallback callback, - Integer hue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveToHue( - chipClusterPtr, - callback, - hue, - direction, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveToHueAndSaturation( - DefaultClusterCallback callback, - Integer hue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - moveToHueAndSaturation( - chipClusterPtr, - callback, - hue, - saturation, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void moveToHueAndSaturation( - DefaultClusterCallback callback, - Integer hue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveToHueAndSaturation( - chipClusterPtr, - callback, - hue, - saturation, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveToSaturation( - DefaultClusterCallback callback, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - moveToSaturation( - chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToSaturation( - DefaultClusterCallback callback, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveToSaturation( - chipClusterPtr, - callback, - saturation, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void stepColor( - DefaultClusterCallback callback, - Integer stepX, - Integer stepY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - stepColor( - chipClusterPtr, - callback, - stepX, - stepY, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void stepColor( - DefaultClusterCallback callback, - Integer stepX, - Integer stepY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - stepColor( - chipClusterPtr, - callback, - stepX, - stepY, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void stepColorTemperature( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride) { - stepColorTemperature( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - colorTemperatureMinimum, - colorTemperatureMaximum, - optionsMask, - optionsOverride, - null); - } - - public void stepColorTemperature( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - stepColorTemperature( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - colorTemperatureMinimum, - colorTemperatureMaximum, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void stepHue( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - stepHue( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void stepHue( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - stepHue( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void stepSaturation( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - stepSaturation( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void stepSaturation( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - stepSaturation( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void stopMoveStep( - DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride) { + public void moveSaturation(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToColor(DefaultClusterCallback callback + , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToColor(DefaultClusterCallback callback + , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToColorTemperature(DefaultClusterCallback callback + , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToColorTemperature(chipClusterPtr, callback, colorTemperature, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToColorTemperature(DefaultClusterCallback callback + , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToColorTemperature(chipClusterPtr, callback, colorTemperature, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToHue(DefaultClusterCallback callback + , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToHue(DefaultClusterCallback callback + , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToHueAndSaturation(DefaultClusterCallback callback + , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToHueAndSaturation(DefaultClusterCallback callback + , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToSaturation(DefaultClusterCallback callback + , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToSaturation(DefaultClusterCallback callback + , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepColor(DefaultClusterCallback callback + , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, null); + } + + public void stepColor(DefaultClusterCallback callback + , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepColorTemperature(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride) { + stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, null); + } + + public void stepColorTemperature(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); + } + + public void stepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepSaturation(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); + } + + public void stepSaturation(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stopMoveStep(DefaultClusterCallback callback + , Integer optionsMask, Integer optionsOverride) { stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, null); } - public void stopMoveStep( - DefaultClusterCallback callback, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { + public void stopMoveStep(DefaultClusterCallback callback + , Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, timedInvokeTimeoutMs); } + private native void colorLoopSet(long chipClusterPtr, DefaultClusterCallback Callback + , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedMoveHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedMoveToHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedMoveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedStepHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveColor(long chipClusterPtr, DefaultClusterCallback Callback + , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToColor(long chipClusterPtr, DefaultClusterCallback Callback + , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback + , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepColor(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopMoveStep(long chipClusterPtr, DefaultClusterCallback Callback + , Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void colorLoopSet( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer updateFlags, - Integer action, - Integer direction, - Integer time, - Integer startHue, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enhancedMoveHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enhancedMoveToHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer enhancedHue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enhancedMoveToHueAndSaturation( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer enhancedHue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enhancedStepHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveColor( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer rateX, - Integer rateY, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveColorTemperature( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveSaturation( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToColor( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer colorX, - Integer colorY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToColorTemperature( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer colorTemperature, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer hue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToHueAndSaturation( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer hue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToSaturation( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stepColor( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepX, - Integer stepY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stepColorTemperature( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stepHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stepSaturation( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopMoveStep( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readCurrentHueAttribute(IntegerAttributeCallback callback) { + public void readCurrentHueAttribute( + IntegerAttributeCallback callback + ) { readCurrentHueAttribute(chipClusterPtr, callback); } - public void subscribeCurrentHueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentSaturationAttribute(IntegerAttributeCallback callback) { + public void readCurrentSaturationAttribute( + IntegerAttributeCallback callback + ) { readCurrentSaturationAttribute(chipClusterPtr, callback); } - public void subscribeCurrentSaturationAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentSaturationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRemainingTimeAttribute(IntegerAttributeCallback callback) { + public void readRemainingTimeAttribute( + IntegerAttributeCallback callback + ) { readRemainingTimeAttribute(chipClusterPtr, callback); } - public void subscribeRemainingTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentXAttribute(IntegerAttributeCallback callback) { + public void readCurrentXAttribute( + IntegerAttributeCallback callback + ) { readCurrentXAttribute(chipClusterPtr, callback); } - public void subscribeCurrentXAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentYAttribute(IntegerAttributeCallback callback) { + public void readCurrentYAttribute( + IntegerAttributeCallback callback + ) { readCurrentYAttribute(chipClusterPtr, callback); } - public void subscribeCurrentYAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDriftCompensationAttribute(IntegerAttributeCallback callback) { + public void readDriftCompensationAttribute( + IntegerAttributeCallback callback + ) { readDriftCompensationAttribute(chipClusterPtr, callback); } - public void subscribeDriftCompensationAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDriftCompensationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCompensationTextAttribute(CharStringAttributeCallback callback) { + public void readCompensationTextAttribute( + CharStringAttributeCallback callback + ) { readCompensationTextAttribute(chipClusterPtr, callback); } - public void subscribeCompensationTextAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCompensationTextAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTemperatureAttribute(IntegerAttributeCallback callback) { + public void readColorTemperatureAttribute( + IntegerAttributeCallback callback + ) { readColorTemperatureAttribute(chipClusterPtr, callback); } - public void subscribeColorTemperatureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorModeAttribute(IntegerAttributeCallback callback) { + public void readColorModeAttribute( + IntegerAttributeCallback callback + ) { readColorModeAttribute(chipClusterPtr, callback); } - public void subscribeColorModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorControlOptionsAttribute(IntegerAttributeCallback callback) { + public void readColorControlOptionsAttribute( + IntegerAttributeCallback callback + ) { readColorControlOptionsAttribute(chipClusterPtr, callback); } - public void writeColorControlOptionsAttribute(DefaultClusterCallback callback, Integer value) { writeColorControlOptionsAttribute(chipClusterPtr, callback, value, null); } - public void writeColorControlOptionsAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorControlOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorControlOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorControlOptionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorControlOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfPrimariesAttribute(IntegerAttributeCallback callback) { + public void readNumberOfPrimariesAttribute( + IntegerAttributeCallback callback + ) { readNumberOfPrimariesAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfPrimariesAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNumberOfPrimariesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1XAttribute(IntegerAttributeCallback callback) { + public void readPrimary1XAttribute( + IntegerAttributeCallback callback + ) { readPrimary1XAttribute(chipClusterPtr, callback); } - public void subscribePrimary1XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary1XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1YAttribute(IntegerAttributeCallback callback) { + public void readPrimary1YAttribute( + IntegerAttributeCallback callback + ) { readPrimary1YAttribute(chipClusterPtr, callback); } - public void subscribePrimary1YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary1YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary1IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary1IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary1IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary1IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2XAttribute(IntegerAttributeCallback callback) { + public void readPrimary2XAttribute( + IntegerAttributeCallback callback + ) { readPrimary2XAttribute(chipClusterPtr, callback); } - public void subscribePrimary2XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary2XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2YAttribute(IntegerAttributeCallback callback) { + public void readPrimary2YAttribute( + IntegerAttributeCallback callback + ) { readPrimary2YAttribute(chipClusterPtr, callback); } - public void subscribePrimary2YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary2YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary2IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary2IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary2IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary2IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3XAttribute(IntegerAttributeCallback callback) { + public void readPrimary3XAttribute( + IntegerAttributeCallback callback + ) { readPrimary3XAttribute(chipClusterPtr, callback); } - public void subscribePrimary3XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary3XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3YAttribute(IntegerAttributeCallback callback) { + public void readPrimary3YAttribute( + IntegerAttributeCallback callback + ) { readPrimary3YAttribute(chipClusterPtr, callback); } - public void subscribePrimary3YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary3YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary3IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary3IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary3IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary3IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4XAttribute(IntegerAttributeCallback callback) { + public void readPrimary4XAttribute( + IntegerAttributeCallback callback + ) { readPrimary4XAttribute(chipClusterPtr, callback); } - public void subscribePrimary4XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary4XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4YAttribute(IntegerAttributeCallback callback) { + public void readPrimary4YAttribute( + IntegerAttributeCallback callback + ) { readPrimary4YAttribute(chipClusterPtr, callback); } - public void subscribePrimary4YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary4YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary4IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary4IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary4IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary4IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5XAttribute(IntegerAttributeCallback callback) { + public void readPrimary5XAttribute( + IntegerAttributeCallback callback + ) { readPrimary5XAttribute(chipClusterPtr, callback); } - public void subscribePrimary5XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary5XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5YAttribute(IntegerAttributeCallback callback) { + public void readPrimary5YAttribute( + IntegerAttributeCallback callback + ) { readPrimary5YAttribute(chipClusterPtr, callback); } - public void subscribePrimary5YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary5YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary5IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary5IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary5IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary5IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6XAttribute(IntegerAttributeCallback callback) { + public void readPrimary6XAttribute( + IntegerAttributeCallback callback + ) { readPrimary6XAttribute(chipClusterPtr, callback); } - public void subscribePrimary6XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary6XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6YAttribute(IntegerAttributeCallback callback) { + public void readPrimary6YAttribute( + IntegerAttributeCallback callback + ) { readPrimary6YAttribute(chipClusterPtr, callback); } - public void subscribePrimary6YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary6YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary6IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary6IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary6IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary6IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWhitePointXAttribute(IntegerAttributeCallback callback) { + public void readWhitePointXAttribute( + IntegerAttributeCallback callback + ) { readWhitePointXAttribute(chipClusterPtr, callback); } - public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value) { writeWhitePointXAttribute(chipClusterPtr, callback, value, null); } - public void writeWhitePointXAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWhitePointXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeWhitePointXAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWhitePointXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWhitePointYAttribute(IntegerAttributeCallback callback) { + public void readWhitePointYAttribute( + IntegerAttributeCallback callback + ) { readWhitePointYAttribute(chipClusterPtr, callback); } - public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value) { writeWhitePointYAttribute(chipClusterPtr, callback, value, null); } - public void writeWhitePointYAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWhitePointYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeWhitePointYAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWhitePointYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRXAttribute(IntegerAttributeCallback callback) { + public void readColorPointRXAttribute( + IntegerAttributeCallback callback + ) { readColorPointRXAttribute(chipClusterPtr, callback); } - public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRXAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointRXAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointRXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRYAttribute(IntegerAttributeCallback callback) { + public void readColorPointRYAttribute( + IntegerAttributeCallback callback + ) { readColorPointRYAttribute(chipClusterPtr, callback); } - public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRYAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointRYAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointRYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRIntensityAttribute(IntegerAttributeCallback callback) { + public void readColorPointRIntensityAttribute( + IntegerAttributeCallback callback + ) { readColorPointRIntensityAttribute(chipClusterPtr, callback); } - public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRIntensityAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointRIntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointRIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGXAttribute(IntegerAttributeCallback callback) { + public void readColorPointGXAttribute( + IntegerAttributeCallback callback + ) { readColorPointGXAttribute(chipClusterPtr, callback); } - public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGXAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointGXAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointGXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGYAttribute(IntegerAttributeCallback callback) { + public void readColorPointGYAttribute( + IntegerAttributeCallback callback + ) { readColorPointGYAttribute(chipClusterPtr, callback); } - public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGYAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointGYAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointGYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGIntensityAttribute(IntegerAttributeCallback callback) { + public void readColorPointGIntensityAttribute( + IntegerAttributeCallback callback + ) { readColorPointGIntensityAttribute(chipClusterPtr, callback); } - public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGIntensityAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointGIntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointGIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBXAttribute(IntegerAttributeCallback callback) { + public void readColorPointBXAttribute( + IntegerAttributeCallback callback + ) { readColorPointBXAttribute(chipClusterPtr, callback); } - public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBXAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointBXAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointBXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBYAttribute(IntegerAttributeCallback callback) { + public void readColorPointBYAttribute( + IntegerAttributeCallback callback + ) { readColorPointBYAttribute(chipClusterPtr, callback); } - public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBYAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointBYAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointBYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBIntensityAttribute(IntegerAttributeCallback callback) { + public void readColorPointBIntensityAttribute( + IntegerAttributeCallback callback + ) { readColorPointBIntensityAttribute(chipClusterPtr, callback); } - public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBIntensityAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointBIntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointBIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnhancedCurrentHueAttribute(IntegerAttributeCallback callback) { + public void readEnhancedCurrentHueAttribute( + IntegerAttributeCallback callback + ) { readEnhancedCurrentHueAttribute(chipClusterPtr, callback); } - public void subscribeEnhancedCurrentHueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnhancedCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnhancedColorModeAttribute(IntegerAttributeCallback callback) { + public void readEnhancedColorModeAttribute( + IntegerAttributeCallback callback + ) { readEnhancedColorModeAttribute(chipClusterPtr, callback); } - public void subscribeEnhancedColorModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnhancedColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopActiveAttribute(IntegerAttributeCallback callback) { + public void readColorLoopActiveAttribute( + IntegerAttributeCallback callback + ) { readColorLoopActiveAttribute(chipClusterPtr, callback); } - public void subscribeColorLoopActiveAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorLoopActiveAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopDirectionAttribute(IntegerAttributeCallback callback) { + public void readColorLoopDirectionAttribute( + IntegerAttributeCallback callback + ) { readColorLoopDirectionAttribute(chipClusterPtr, callback); } - public void subscribeColorLoopDirectionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorLoopDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopTimeAttribute(IntegerAttributeCallback callback) { + public void readColorLoopTimeAttribute( + IntegerAttributeCallback callback + ) { readColorLoopTimeAttribute(chipClusterPtr, callback); } - public void subscribeColorLoopTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorLoopTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopStartEnhancedHueAttribute(IntegerAttributeCallback callback) { + public void readColorLoopStartEnhancedHueAttribute( + IntegerAttributeCallback callback + ) { readColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback); } - public void subscribeColorLoopStartEnhancedHueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeColorLoopStartEnhancedHueAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopStoredEnhancedHueAttribute(IntegerAttributeCallback callback) { + public void readColorLoopStoredEnhancedHueAttribute( + IntegerAttributeCallback callback + ) { readColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback); } - public void subscribeColorLoopStoredEnhancedHueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeColorLoopStoredEnhancedHueAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorCapabilitiesAttribute(IntegerAttributeCallback callback) { + public void readColorCapabilitiesAttribute( + IntegerAttributeCallback callback + ) { readColorCapabilitiesAttribute(chipClusterPtr, callback); } - public void subscribeColorCapabilitiesAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTempPhysicalMinAttribute(IntegerAttributeCallback callback) { + public void readColorTempPhysicalMinAttribute( + IntegerAttributeCallback callback + ) { readColorTempPhysicalMinAttribute(chipClusterPtr, callback); } - public void subscribeColorTempPhysicalMinAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorTempPhysicalMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTempPhysicalMaxAttribute(IntegerAttributeCallback callback) { + public void readColorTempPhysicalMaxAttribute( + IntegerAttributeCallback callback + ) { readColorTempPhysicalMaxAttribute(chipClusterPtr, callback); } - public void subscribeColorTempPhysicalMaxAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorTempPhysicalMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCoupleColorTempToLevelMinMiredsAttribute(IntegerAttributeCallback callback) { + public void readCoupleColorTempToLevelMinMiredsAttribute( + IntegerAttributeCallback callback + ) { readCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback); } - public void subscribeCoupleColorTempToLevelMinMiredsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeCoupleColorTempToLevelMinMiredsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpColorTemperatureMiredsAttribute(IntegerAttributeCallback callback) { + public void readStartUpColorTemperatureMiredsAttribute( + IntegerAttributeCallback callback + ) { readStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback); } - - public void writeStartUpColorTemperatureMiredsAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpColorTemperatureMiredsAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeStartUpColorTemperatureMiredsAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeStartUpColorTemperatureMiredsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeStartUpColorTemperatureMiredsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentSaturationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentSaturationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDriftCompensationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDriftCompensationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCompensationTextAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeCompensationTextAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorControlOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorControlOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorControlOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfPrimariesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfPrimariesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary1XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary1XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary1YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary1YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary1IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary1IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary2XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary2XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary2YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary2YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary2IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary2IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary3XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary3XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary3YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary3YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary3IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary3IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary4XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary4XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary4YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary4YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary4IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary4IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary5XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary5XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary5YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary5YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary5IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary5IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary6XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary6XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary6YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary6YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary6IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary6IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWhitePointXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeWhitePointXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeWhitePointXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWhitePointYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeWhitePointYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeWhitePointYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointRXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointRXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointRXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointRYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointRYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointRYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointRIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointRIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointRIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointGXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointGXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointGXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointGYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointGYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointGYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointGIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointGIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointGIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointBXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointBXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointBXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointBYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointBYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointBYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointBIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointBIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointBIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnhancedCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEnhancedCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnhancedColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEnhancedColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopActiveAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopActiveAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopStartEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopStartEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorTempPhysicalMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorTempPhysicalMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } - private native void readCurrentSaturationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public static class ContentLauncherCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1290L; - private native void subscribeCurrentSaturationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public ContentLauncherCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } - private native void readRemainingTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + @Override + public native long initWithDevice(long devicePtr, int endpointId); - private native void subscribeRemainingTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public void launchContentRequest(LaunchResponseCallback callback + , Boolean autoPlay, String data, ArrayList search) { + launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, null); + } - private native void readCurrentXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public void launchContentRequest(LaunchResponseCallback callback + , Boolean autoPlay, String data, ArrayList search + , int timedInvokeTimeoutMs) { + launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, timedInvokeTimeoutMs); + } - private native void subscribeCurrentXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public void launchURLRequest(LaunchResponseCallback callback + , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation) { + launchURLRequest(chipClusterPtr, callback, contentURL, displayString, brandingInformation, null); + } - private native void readCurrentYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public void launchURLRequest(LaunchResponseCallback callback + , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation + , int timedInvokeTimeoutMs) { + launchURLRequest(chipClusterPtr, callback, contentURL, displayString, brandingInformation, timedInvokeTimeoutMs); + } + private native void launchContentRequest(long chipClusterPtr, LaunchResponseCallback Callback + , Boolean autoPlay, String data, ArrayList search + , @Nullable Integer timedInvokeTimeoutMs); + private native void launchURLRequest(long chipClusterPtr, LaunchResponseCallback Callback + , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation + , @Nullable Integer timedInvokeTimeoutMs); + public interface LaunchResponseCallback { + void onSuccess(Integer status, String data); + + void onError(Exception error); + } - private native void subscribeCurrentYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - private native void readDriftCompensationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public interface AcceptHeaderListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void subscribeDriftCompensationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public void readAcceptHeaderListAttribute( + AcceptHeaderListAttributeCallback callback + ) { + readAcceptHeaderListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptHeaderListAttribute( + AcceptHeaderListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptHeaderListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readCompensationTextAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); + public void readSupportedStreamingProtocolsAttribute( + LongAttributeCallback callback + ) { + readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback); + } + public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value) { + writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, null); + } - private native void subscribeCompensationTextAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); + public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeSupportedStreamingProtocolsAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readColorTemperatureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void subscribeColorTemperatureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int 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 readColorModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorControlOptionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorControlOptionsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorControlOptionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfPrimariesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfPrimariesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary1XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary1XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary1YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary1YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary1IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary1IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary2XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary2XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary2YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary2YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary2IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary2IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary3XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary3XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary3YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary3YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary3IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary3IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary4XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary4XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary4YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary4YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary4IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary4IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary5XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary5XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary5YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary5YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary5IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary5IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary6XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary6XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary6YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary6YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary6IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary6IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readWhitePointXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeWhitePointXAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeWhitePointXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readWhitePointYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeWhitePointYAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeWhitePointYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointRXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointRXAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointRXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointRYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointRYAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointRYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointRIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointRIntensityAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointRIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointGXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointGXAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointGXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointGYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointGYAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointGYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointGIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointGIntensityAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointGIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointBXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointBXAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointBXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointBYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointBYAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointBYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointBIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointBIntensityAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointBIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnhancedCurrentHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeEnhancedCurrentHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnhancedColorModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeEnhancedColorModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorLoopActiveAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorLoopActiveAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorLoopDirectionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorLoopDirectionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorLoopTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorLoopTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorLoopStartEnhancedHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorLoopStartEnhancedHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorLoopStoredEnhancedHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorLoopStoredEnhancedHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorCapabilitiesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorCapabilitiesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorTempPhysicalMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorTempPhysicalMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorTempPhysicalMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorTempPhysicalMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCoupleColorTempToLevelMinMiredsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCoupleColorTempToLevelMinMiredsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStartUpColorTemperatureMiredsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeStartUpColorTemperatureMiredsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeStartUpColorTemperatureMiredsAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - } - - public static class ContentLauncherCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1290L; - - public ContentLauncherCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } - - @Override - public native long initWithDevice(long devicePtr, int endpointId); - - public void launchContentRequest( - LaunchResponseCallback callback, - Boolean autoPlay, - String data, - ArrayList search) { - launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, null); - } - - public void launchContentRequest( - LaunchResponseCallback callback, - Boolean autoPlay, - String data, - ArrayList search, - int timedInvokeTimeoutMs) { - launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, timedInvokeTimeoutMs); - } - - public void launchURLRequest( - LaunchResponseCallback callback, - String contentURL, - String displayString, - ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation) { - launchURLRequest( - chipClusterPtr, callback, contentURL, displayString, brandingInformation, null); - } - - public void launchURLRequest( - LaunchResponseCallback callback, - String contentURL, - String displayString, - ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation, - int timedInvokeTimeoutMs) { - launchURLRequest( - chipClusterPtr, - callback, - contentURL, - displayString, - brandingInformation, - timedInvokeTimeoutMs); - } - - private native void launchContentRequest( - long chipClusterPtr, - LaunchResponseCallback Callback, - Boolean autoPlay, - String data, - ArrayList search, - @Nullable Integer timedInvokeTimeoutMs); - - private native void launchURLRequest( - long chipClusterPtr, - LaunchResponseCallback Callback, - String contentURL, - String displayString, - ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation, - @Nullable Integer timedInvokeTimeoutMs); - - public interface LaunchResponseCallback { - void onSuccess(Integer status, String data); - - void onError(Exception error); - } - - public interface AcceptHeaderListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readAcceptHeaderListAttribute(AcceptHeaderListAttributeCallback callback) { - readAcceptHeaderListAttribute(chipClusterPtr, callback); - } - - public void subscribeAcceptHeaderListAttribute( - AcceptHeaderListAttributeCallback callback, int minInterval, int maxInterval) { - subscribeAcceptHeaderListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readSupportedStreamingProtocolsAttribute(LongAttributeCallback callback) { - readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback); - } - - public void writeSupportedStreamingProtocolsAttribute( - DefaultClusterCallback callback, Long value) { - writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, null); - } - - public void writeSupportedStreamingProtocolsAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { - writeSupportedStreamingProtocolsAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); - } - - public void subscribeSupportedStreamingProtocolsAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeSupportedStreamingProtocolsAttribute( - 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 readClusterRevisionAttribute(IntegerAttributeCallback callback) { - readClusterRevisionAttribute(chipClusterPtr, callback); - } - - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - private native void readAcceptHeaderListAttribute( - long chipClusterPtr, AcceptHeaderListAttributeCallback callback); - - private native void subscribeAcceptHeaderListAttribute( - long chipClusterPtr, - AcceptHeaderListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSupportedStreamingProtocolsAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void writeSupportedStreamingProtocolsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeSupportedStreamingProtocolsAttribute( - long chipClusterPtr, LongAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - } + private native void readAcceptHeaderListAttribute(long chipClusterPtr, + AcceptHeaderListAttributeCallback callback + ); + private native void subscribeAcceptHeaderListAttribute(long chipClusterPtr, + AcceptHeaderListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSupportedStreamingProtocolsAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeSupportedStreamingProtocolsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSupportedStreamingProtocolsAttribute(long chipClusterPtr, + LongAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } public static class DescriptorCluster extends BaseChipCluster { public static final long CLUSTER_ID = 29L; @@ -4436,147 +3846,145 @@ public DescriptorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface DeviceListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ServerListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ClientListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface PartsListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface DeviceListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ServerListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ClientListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface PartsListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readDeviceListAttribute(DeviceListAttributeCallback callback) { + public void readDeviceListAttribute( + DeviceListAttributeCallback callback + ) { readDeviceListAttribute(chipClusterPtr, callback); } - public void subscribeDeviceListAttribute( - DeviceListAttributeCallback callback, int minInterval, int maxInterval) { + DeviceListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeDeviceListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readServerListAttribute(ServerListAttributeCallback callback) { + public void readServerListAttribute( + ServerListAttributeCallback callback + ) { readServerListAttribute(chipClusterPtr, callback); } - public void subscribeServerListAttribute( - ServerListAttributeCallback callback, int minInterval, int maxInterval) { + ServerListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeServerListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClientListAttribute(ClientListAttributeCallback callback) { + public void readClientListAttribute( + ClientListAttributeCallback callback + ) { readClientListAttribute(chipClusterPtr, callback); } - public void subscribeClientListAttribute( - ClientListAttributeCallback callback, int minInterval, int maxInterval) { + ClientListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeClientListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartsListAttribute(PartsListAttributeCallback callback) { + public void readPartsListAttribute( + PartsListAttributeCallback callback + ) { readPartsListAttribute(chipClusterPtr, callback); } - public void subscribePartsListAttribute( - PartsListAttributeCallback callback, int minInterval, int maxInterval) { + PartsListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribePartsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readDeviceListAttribute( - long chipClusterPtr, DeviceListAttributeCallback callback); - - private native void subscribeDeviceListAttribute( - long chipClusterPtr, - DeviceListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readServerListAttribute( - long chipClusterPtr, ServerListAttributeCallback callback); - - private native void subscribeServerListAttribute( - long chipClusterPtr, - ServerListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readClientListAttribute( - long chipClusterPtr, ClientListAttributeCallback callback); - - private native void subscribeClientListAttribute( - long chipClusterPtr, - ClientListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readPartsListAttribute( - long chipClusterPtr, PartsListAttributeCallback callback); - - private native void subscribePartsListAttribute( - long chipClusterPtr, PartsListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readDeviceListAttribute(long chipClusterPtr, + DeviceListAttributeCallback callback + ); + private native void subscribeDeviceListAttribute(long chipClusterPtr, + DeviceListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readServerListAttribute(long chipClusterPtr, + ServerListAttributeCallback callback + ); + private native void subscribeServerListAttribute(long chipClusterPtr, + ServerListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readClientListAttribute(long chipClusterPtr, + ClientListAttributeCallback callback + ); + private native void subscribeClientListAttribute(long chipClusterPtr, + ClientListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPartsListAttribute(long chipClusterPtr, + PartsListAttributeCallback callback + ); + private native void subscribePartsListAttribute(long chipClusterPtr, + PartsListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class DiagnosticLogsCluster extends BaseChipCluster { @@ -4589,69 +3997,50 @@ public DiagnosticLogsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void retrieveLogsRequest( - RetrieveLogsResponseCallback callback, - Integer intent, - Integer requestedProtocol, - byte[] transferFileDesignator) { - retrieveLogsRequest( - chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null); - } - - public void retrieveLogsRequest( - RetrieveLogsResponseCallback callback, - Integer intent, - Integer requestedProtocol, - byte[] transferFileDesignator, - int timedInvokeTimeoutMs) { - retrieveLogsRequest( - chipClusterPtr, - callback, - intent, - requestedProtocol, - transferFileDesignator, - timedInvokeTimeoutMs); - } - - private native void retrieveLogsRequest( - long chipClusterPtr, - RetrieveLogsResponseCallback Callback, - Integer intent, - Integer requestedProtocol, - byte[] transferFileDesignator, - @Nullable Integer timedInvokeTimeoutMs); + public void retrieveLogsRequest(RetrieveLogsResponseCallback callback + , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator) { + retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null); + } + public void retrieveLogsRequest(RetrieveLogsResponseCallback callback + , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator + , int timedInvokeTimeoutMs) { + retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, timedInvokeTimeoutMs); + } + private native void retrieveLogsRequest(long chipClusterPtr, RetrieveLogsResponseCallback Callback + , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator + , @Nullable Integer timedInvokeTimeoutMs); public interface RetrieveLogsResponseCallback { void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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); } public static class DoorLockCluster extends BaseChipCluster { @@ -4664,886 +4053,733 @@ public DoorLockCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void clearCredential( - DefaultClusterCallback callback, - @Nullable ChipStructs.DoorLockClusterDlCredential credential, - int timedInvokeTimeoutMs) { + + public void clearCredential(DefaultClusterCallback callback + , @Nullable ChipStructs.DoorLockClusterDlCredential credential + , int timedInvokeTimeoutMs) { clearCredential(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); } - public void clearUser( - DefaultClusterCallback callback, Integer userIndex, int timedInvokeTimeoutMs) { + + public void clearUser(DefaultClusterCallback callback + , Integer userIndex + , int timedInvokeTimeoutMs) { clearUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); } - public void clearWeekDaySchedule( - DefaultClusterCallback callback, Integer weekDayIndex, Integer userIndex) { + public void clearWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex) { clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); } - public void clearWeekDaySchedule( - DefaultClusterCallback callback, - Integer weekDayIndex, - Integer userIndex, - int timedInvokeTimeoutMs) { + public void clearWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); } - public void clearYearDaySchedule( - DefaultClusterCallback callback, Integer yearDayIndex, Integer userIndex) { + public void clearYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex) { clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); } - public void clearYearDaySchedule( - DefaultClusterCallback callback, - Integer yearDayIndex, - Integer userIndex, - int timedInvokeTimeoutMs) { + public void clearYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); } - public void getCredentialStatus( - GetCredentialStatusResponseCallback callback, - ChipStructs.DoorLockClusterDlCredential credential) { + public void getCredentialStatus(GetCredentialStatusResponseCallback callback + , ChipStructs.DoorLockClusterDlCredential credential) { getCredentialStatus(chipClusterPtr, callback, credential, null); } - public void getCredentialStatus( - GetCredentialStatusResponseCallback callback, - ChipStructs.DoorLockClusterDlCredential credential, - int timedInvokeTimeoutMs) { + public void getCredentialStatus(GetCredentialStatusResponseCallback callback + , ChipStructs.DoorLockClusterDlCredential credential + , int timedInvokeTimeoutMs) { getCredentialStatus(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); } - public void getUser(GetUserResponseCallback callback, Integer userIndex) { + public void getUser(GetUserResponseCallback callback + , Integer userIndex) { getUser(chipClusterPtr, callback, userIndex, null); } - public void getUser( - GetUserResponseCallback callback, Integer userIndex, int timedInvokeTimeoutMs) { + public void getUser(GetUserResponseCallback callback + , Integer userIndex + , int timedInvokeTimeoutMs) { getUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); } - public void getWeekDaySchedule( - GetWeekDayScheduleResponseCallback callback, Integer weekDayIndex, Integer userIndex) { + public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback + , Integer weekDayIndex, Integer userIndex) { getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); } - public void getWeekDaySchedule( - GetWeekDayScheduleResponseCallback callback, - Integer weekDayIndex, - Integer userIndex, - int timedInvokeTimeoutMs) { + public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback + , Integer weekDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); } - public void getYearDaySchedule( - GetYearDayScheduleResponseCallback callback, Integer yearDayIndex, Integer userIndex) { + public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback + , Integer yearDayIndex, Integer userIndex) { getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); } - public void getYearDaySchedule( - GetYearDayScheduleResponseCallback callback, - Integer yearDayIndex, - Integer userIndex, - int timedInvokeTimeoutMs) { + public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback + , Integer yearDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); } - public void lockDoor( - DefaultClusterCallback callback, Optional pinCode, int timedInvokeTimeoutMs) { + + public void lockDoor(DefaultClusterCallback callback + , Optional pinCode + , int timedInvokeTimeoutMs) { lockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); } - public void setCredential( - SetCredentialResponseCallback callback, - Integer operationType, - ChipStructs.DoorLockClusterDlCredential credential, - byte[] credentialData, - @Nullable Integer userIndex, - @Nullable Integer userStatus, - @Nullable Integer userType, - int timedInvokeTimeoutMs) { - setCredential( - chipClusterPtr, - callback, - operationType, - credential, - credentialData, - userIndex, - userStatus, - userType, - timedInvokeTimeoutMs); - } - - public void setUser( - DefaultClusterCallback callback, - Integer operationType, - Integer userIndex, - @Nullable String userName, - @Nullable Long userUniqueId, - @Nullable Integer userStatus, - @Nullable Integer userType, - @Nullable Integer credentialRule, - int timedInvokeTimeoutMs) { - setUser( - chipClusterPtr, - callback, - operationType, - userIndex, - userName, - userUniqueId, - userStatus, - userType, - credentialRule, - timedInvokeTimeoutMs); - } - - public void setWeekDaySchedule( - DefaultClusterCallback callback, - Integer weekDayIndex, - Integer userIndex, - Integer daysMask, - Integer startHour, - Integer startMinute, - Integer endHour, - Integer endMinute) { - setWeekDaySchedule( - chipClusterPtr, - callback, - weekDayIndex, - userIndex, - daysMask, - startHour, - startMinute, - endHour, - endMinute, - null); - } - - public void setWeekDaySchedule( - DefaultClusterCallback callback, - Integer weekDayIndex, - Integer userIndex, - Integer daysMask, - Integer startHour, - Integer startMinute, - Integer endHour, - Integer endMinute, - int timedInvokeTimeoutMs) { - setWeekDaySchedule( - chipClusterPtr, - callback, - weekDayIndex, - userIndex, - daysMask, - startHour, - startMinute, - endHour, - endMinute, - timedInvokeTimeoutMs); - } - - public void setYearDaySchedule( - DefaultClusterCallback callback, - Integer yearDayIndex, - Integer userIndex, - Long localStartTime, - Long localEndTime) { - setYearDaySchedule( - chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null); - } - - public void setYearDaySchedule( - DefaultClusterCallback callback, - Integer yearDayIndex, - Integer userIndex, - Long localStartTime, - Long localEndTime, - int timedInvokeTimeoutMs) { - setYearDaySchedule( - chipClusterPtr, - callback, - yearDayIndex, - userIndex, - localStartTime, - localEndTime, - timedInvokeTimeoutMs); - } - - public void unlockDoor( - DefaultClusterCallback callback, Optional pinCode, int timedInvokeTimeoutMs) { - unlockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); + + public void setCredential(SetCredentialResponseCallback callback + , Integer operationType, ChipStructs.DoorLockClusterDlCredential credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType + , int timedInvokeTimeoutMs) { + setCredential(chipClusterPtr, callback, operationType, credential, credentialData, userIndex, userStatus, userType, timedInvokeTimeoutMs); } - public void unlockWithTimeout( - DefaultClusterCallback callback, - Integer timeout, - Optional pinCode, - int timedInvokeTimeoutMs) { - unlockWithTimeout(chipClusterPtr, callback, timeout, pinCode, timedInvokeTimeoutMs); + + public void setUser(DefaultClusterCallback callback + , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule + , int timedInvokeTimeoutMs) { + setUser(chipClusterPtr, callback, operationType, userIndex, userName, userUniqueId, userStatus, userType, credentialRule, timedInvokeTimeoutMs); } - private native void clearCredential( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable ChipStructs.DoorLockClusterDlCredential credential, - @Nullable Integer timedInvokeTimeoutMs); - - private native void clearUser( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void clearWeekDaySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer weekDayIndex, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void clearYearDaySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer yearDayIndex, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getCredentialStatus( - long chipClusterPtr, - GetCredentialStatusResponseCallback Callback, - ChipStructs.DoorLockClusterDlCredential credential, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getUser( - long chipClusterPtr, - GetUserResponseCallback Callback, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getWeekDaySchedule( - long chipClusterPtr, - GetWeekDayScheduleResponseCallback Callback, - Integer weekDayIndex, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getYearDaySchedule( - long chipClusterPtr, - GetYearDayScheduleResponseCallback Callback, - Integer yearDayIndex, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void lockDoor( - long chipClusterPtr, - DefaultClusterCallback Callback, - Optional pinCode, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setCredential( - long chipClusterPtr, - SetCredentialResponseCallback Callback, - Integer operationType, - ChipStructs.DoorLockClusterDlCredential credential, - byte[] credentialData, - @Nullable Integer userIndex, - @Nullable Integer userStatus, - @Nullable Integer userType, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setUser( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer operationType, - Integer userIndex, - @Nullable String userName, - @Nullable Long userUniqueId, - @Nullable Integer userStatus, - @Nullable Integer userType, - @Nullable Integer credentialRule, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setWeekDaySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer weekDayIndex, - Integer userIndex, - Integer daysMask, - Integer startHour, - Integer startMinute, - Integer endHour, - Integer endMinute, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setYearDaySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer yearDayIndex, - Integer userIndex, - Long localStartTime, - Long localEndTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void unlockDoor( - long chipClusterPtr, - DefaultClusterCallback Callback, - Optional pinCode, - @Nullable Integer timedInvokeTimeoutMs); - - private native void unlockWithTimeout( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer timeout, - Optional pinCode, - @Nullable Integer timedInvokeTimeoutMs); + public void setWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute) { + setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, null); + } + + public void setWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute + , int timedInvokeTimeoutMs) { + setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, timedInvokeTimeoutMs); + } + + public void setYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime) { + setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null); + } + + public void setYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime + , int timedInvokeTimeoutMs) { + setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, timedInvokeTimeoutMs); + } + + + public void unlockDoor(DefaultClusterCallback callback + , Optional pinCode + , int timedInvokeTimeoutMs) { + unlockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); + } - public interface GetCredentialStatusResponseCallback { - void onSuccess( - Boolean credentialExists, - @Nullable Integer userIndex, - @Nullable Integer nextCredentialIndex); + public void unlockWithTimeout(DefaultClusterCallback callback + , Integer timeout, Optional pinCode + , int timedInvokeTimeoutMs) { + unlockWithTimeout(chipClusterPtr, callback, timeout, pinCode, timedInvokeTimeoutMs); + } + private native void clearCredential(long chipClusterPtr, DefaultClusterCallback Callback + , @Nullable ChipStructs.DoorLockClusterDlCredential credential + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearUser(long chipClusterPtr, DefaultClusterCallback Callback + , Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer weekDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer yearDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void getCredentialStatus(long chipClusterPtr, GetCredentialStatusResponseCallback Callback + , ChipStructs.DoorLockClusterDlCredential credential + , @Nullable Integer timedInvokeTimeoutMs); + private native void getUser(long chipClusterPtr, GetUserResponseCallback Callback + , Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void getWeekDaySchedule(long chipClusterPtr, GetWeekDayScheduleResponseCallback Callback + , Integer weekDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void getYearDaySchedule(long chipClusterPtr, GetYearDayScheduleResponseCallback Callback + , Integer yearDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void lockDoor(long chipClusterPtr, DefaultClusterCallback Callback + , Optional pinCode + , @Nullable Integer timedInvokeTimeoutMs); + private native void setCredential(long chipClusterPtr, SetCredentialResponseCallback Callback + , Integer operationType, ChipStructs.DoorLockClusterDlCredential credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType + , @Nullable Integer timedInvokeTimeoutMs); + private native void setUser(long chipClusterPtr, DefaultClusterCallback Callback + , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule + , @Nullable Integer timedInvokeTimeoutMs); + private native void setWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute + , @Nullable Integer timedInvokeTimeoutMs); + private native void setYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void unlockDoor(long chipClusterPtr, DefaultClusterCallback Callback + , Optional pinCode + , @Nullable Integer timedInvokeTimeoutMs); + private native void unlockWithTimeout(long chipClusterPtr, DefaultClusterCallback Callback + , Integer timeout, Optional pinCode + , @Nullable Integer timedInvokeTimeoutMs); + public interface GetCredentialStatusResponseCallback { + void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); + void onError(Exception error); } public interface GetUserResponseCallback { - void onSuccess( - Integer userIndex, - @Nullable String userName, - @Nullable Long userUniqueId, - @Nullable Integer userStatus, - @Nullable Integer userType, - @Nullable Integer credentialRule, - @Nullable ArrayList credentials, - @Nullable Integer creatorFabricIndex, - @Nullable Integer lastModifiedFabricIndex, - @Nullable Integer nextUserIndex); - + void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex); + void onError(Exception error); } public interface GetWeekDayScheduleResponseCallback { - void onSuccess( - Integer weekDayIndex, - Integer userIndex, - Integer status, - Optional daysMask, - Optional startHour, - Optional startMinute, - Optional endHour, - Optional endMinute); - + void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute); + void onError(Exception error); } public interface GetYearDayScheduleResponseCallback { - void onSuccess( - Integer yearDayIndex, - Integer userIndex, - Integer status, - Optional localStartTime, - Optional localEndTime); - + void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime); + void onError(Exception error); } public interface SetCredentialResponseCallback { - void onSuccess( - Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); - + void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); + void onError(Exception error); } - public interface LockStateAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); + public interface LockStateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface DoorStateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - default void onSubscriptionEstablished() {} - } - - public interface DoorStateAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readLockStateAttribute(LockStateAttributeCallback callback) { + public void readLockStateAttribute( + LockStateAttributeCallback callback + ) { readLockStateAttribute(chipClusterPtr, callback); } - public void subscribeLockStateAttribute( - LockStateAttributeCallback callback, int minInterval, int maxInterval) { + LockStateAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLockStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLockTypeAttribute(IntegerAttributeCallback callback) { + public void readLockTypeAttribute( + IntegerAttributeCallback callback + ) { readLockTypeAttribute(chipClusterPtr, callback); } - public void subscribeLockTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLockTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActuatorEnabledAttribute(BooleanAttributeCallback callback) { + public void readActuatorEnabledAttribute( + BooleanAttributeCallback callback + ) { readActuatorEnabledAttribute(chipClusterPtr, callback); } - public void subscribeActuatorEnabledAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActuatorEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDoorStateAttribute(DoorStateAttributeCallback callback) { + public void readDoorStateAttribute( + DoorStateAttributeCallback callback + ) { readDoorStateAttribute(chipClusterPtr, callback); } - public void subscribeDoorStateAttribute( - DoorStateAttributeCallback callback, int minInterval, int maxInterval) { + DoorStateAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeDoorStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfTotalUsersSupportedAttribute(IntegerAttributeCallback callback) { + public void readNumberOfTotalUsersSupportedAttribute( + IntegerAttributeCallback callback + ) { readNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfTotalUsersSupportedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfTotalUsersSupportedAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfPINUsersSupportedAttribute(IntegerAttributeCallback callback) { + public void readNumberOfPINUsersSupportedAttribute( + IntegerAttributeCallback callback + ) { readNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfPINUsersSupportedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfPINUsersSupportedAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfRFIDUsersSupportedAttribute(IntegerAttributeCallback callback) { + public void readNumberOfRFIDUsersSupportedAttribute( + IntegerAttributeCallback callback + ) { readNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfRFIDUsersSupportedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfRFIDUsersSupportedAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNumberOfWeekDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback) { + IntegerAttributeCallback callback + ) { readNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNumberOfYearDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback) { + IntegerAttributeCallback callback + ) { readNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxPINCodeLengthAttribute(IntegerAttributeCallback callback) { + public void readMaxPINCodeLengthAttribute( + IntegerAttributeCallback callback + ) { readMaxPINCodeLengthAttribute(chipClusterPtr, callback); } - public void subscribeMaxPINCodeLengthAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinPINCodeLengthAttribute(IntegerAttributeCallback callback) { + public void readMinPINCodeLengthAttribute( + IntegerAttributeCallback callback + ) { readMinPINCodeLengthAttribute(chipClusterPtr, callback); } - public void subscribeMinPINCodeLengthAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxRFIDCodeLengthAttribute(IntegerAttributeCallback callback) { + public void readMaxRFIDCodeLengthAttribute( + IntegerAttributeCallback callback + ) { readMaxRFIDCodeLengthAttribute(chipClusterPtr, callback); } - public void subscribeMaxRFIDCodeLengthAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinRFIDCodeLengthAttribute(IntegerAttributeCallback callback) { + public void readMinRFIDCodeLengthAttribute( + IntegerAttributeCallback callback + ) { readMinRFIDCodeLengthAttribute(chipClusterPtr, callback); } - public void subscribeMinRFIDCodeLengthAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLanguageAttribute(CharStringAttributeCallback callback) { + public void readLanguageAttribute( + CharStringAttributeCallback callback + ) { readLanguageAttribute(chipClusterPtr, callback); } - public void writeLanguageAttribute(DefaultClusterCallback callback, String value) { writeLanguageAttribute(chipClusterPtr, callback, value, null); } - public void writeLanguageAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLanguageAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLanguageAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLanguageAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLanguageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAutoRelockTimeAttribute(LongAttributeCallback callback) { + public void readAutoRelockTimeAttribute( + LongAttributeCallback callback + ) { readAutoRelockTimeAttribute(chipClusterPtr, callback); } - public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value) { writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeAutoRelockTimeAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeAutoRelockTimeAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAutoRelockTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoundVolumeAttribute(IntegerAttributeCallback callback) { + public void readSoundVolumeAttribute( + IntegerAttributeCallback callback + ) { readSoundVolumeAttribute(chipClusterPtr, callback); } - public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value) { writeSoundVolumeAttribute(chipClusterPtr, callback, value, null); } - public void writeSoundVolumeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSoundVolumeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeSoundVolumeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSoundVolumeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperatingModeAttribute(IntegerAttributeCallback callback) { + public void readOperatingModeAttribute( + IntegerAttributeCallback callback + ) { readOperatingModeAttribute(chipClusterPtr, callback); } - public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value) { writeOperatingModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOperatingModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOperatingModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOperatingModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOperatingModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedOperatingModesAttribute(IntegerAttributeCallback callback) { + public void readSupportedOperatingModesAttribute( + IntegerAttributeCallback callback + ) { readSupportedOperatingModesAttribute(chipClusterPtr, callback); } - public void subscribeSupportedOperatingModesAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSupportedOperatingModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnableOneTouchLockingAttribute(BooleanAttributeCallback callback) { + public void readEnableOneTouchLockingAttribute( + BooleanAttributeCallback callback + ) { readEnableOneTouchLockingAttribute(chipClusterPtr, callback); } - - public void writeEnableOneTouchLockingAttribute( - DefaultClusterCallback callback, Boolean value) { + public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value) { writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, null); } - public void writeEnableOneTouchLockingAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEnableOneTouchLockingAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnableOneTouchLockingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnablePrivacyModeButtonAttribute(BooleanAttributeCallback callback) { + public void readEnablePrivacyModeButtonAttribute( + BooleanAttributeCallback callback + ) { readEnablePrivacyModeButtonAttribute(chipClusterPtr, callback); } - - public void writeEnablePrivacyModeButtonAttribute( - DefaultClusterCallback callback, Boolean value) { + public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value) { writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, null); } - public void writeEnablePrivacyModeButtonAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEnablePrivacyModeButtonAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWrongCodeEntryLimitAttribute(IntegerAttributeCallback callback) { + public void readWrongCodeEntryLimitAttribute( + IntegerAttributeCallback callback + ) { readWrongCodeEntryLimitAttribute(chipClusterPtr, callback); } - public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value) { writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeWrongCodeEntryLimitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeWrongCodeEntryLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLockStateAttribute( - long chipClusterPtr, LockStateAttributeCallback callback); - - private native void subscribeLockStateAttribute( - long chipClusterPtr, LockStateAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLockTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLockTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActuatorEnabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeActuatorEnabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDoorStateAttribute( - long chipClusterPtr, DoorStateAttributeCallback callback); - - private native void subscribeDoorStateAttribute( - long chipClusterPtr, DoorStateAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfTotalUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfTotalUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfPINUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfPINUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfRFIDUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfRFIDUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfWeekDaySchedulesSupportedPerUserAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfYearDaySchedulesSupportedPerUserAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxPINCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxPINCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinPINCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinPINCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxRFIDCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxRFIDCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinRFIDCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinRFIDCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLanguageAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeLanguageAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLanguageAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readAutoRelockTimeAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void writeAutoRelockTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeAutoRelockTimeAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSoundVolumeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeSoundVolumeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeSoundVolumeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOperatingModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOperatingModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOperatingModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSupportedOperatingModesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSupportedOperatingModesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnableOneTouchLockingAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeEnableOneTouchLockingAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEnableOneTouchLockingAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnablePrivacyModeButtonAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeEnablePrivacyModeButtonAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEnablePrivacyModeButtonAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readWrongCodeEntryLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeWrongCodeEntryLimitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeWrongCodeEntryLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readLockStateAttribute(long chipClusterPtr, + LockStateAttributeCallback callback + ); + private native void subscribeLockStateAttribute(long chipClusterPtr, + LockStateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLockTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLockTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActuatorEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeActuatorEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDoorStateAttribute(long chipClusterPtr, + DoorStateAttributeCallback callback + ); + private native void subscribeDoorStateAttribute(long chipClusterPtr, + DoorStateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfPINUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfPINUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLanguageAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeLanguageAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLanguageAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAutoRelockTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeAutoRelockTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeAutoRelockTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSoundVolumeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeSoundVolumeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSoundVolumeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOperatingModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOperatingModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOperatingModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedOperatingModesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSupportedOperatingModesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnableOneTouchLockingAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeEnableOneTouchLockingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnableOneTouchLockingAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnablePrivacyModeButtonAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeEnablePrivacyModeButtonAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnablePrivacyModeButtonAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWrongCodeEntryLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeWrongCodeEntryLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeWrongCodeEntryLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ElectricalMeasurementCluster extends BaseChipCluster { @@ -5556,211 +4792,258 @@ public ElectricalMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMeasurementTypeAttribute(LongAttributeCallback callback) { + public void readMeasurementTypeAttribute( + LongAttributeCallback callback + ) { readMeasurementTypeAttribute(chipClusterPtr, callback); } - public void subscribeMeasurementTypeAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMeasurementTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTotalActivePowerAttribute(LongAttributeCallback callback) { + public void readTotalActivePowerAttribute( + LongAttributeCallback callback + ) { readTotalActivePowerAttribute(chipClusterPtr, callback); } - public void subscribeTotalActivePowerAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTotalActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageAttribute(IntegerAttributeCallback callback) { + public void readRmsVoltageAttribute( + IntegerAttributeCallback callback + ) { readRmsVoltageAttribute(chipClusterPtr, callback); } - public void subscribeRmsVoltageAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageMinAttribute(IntegerAttributeCallback callback) { + public void readRmsVoltageMinAttribute( + IntegerAttributeCallback callback + ) { readRmsVoltageMinAttribute(chipClusterPtr, callback); } - public void subscribeRmsVoltageMinAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsVoltageMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageMaxAttribute(IntegerAttributeCallback callback) { + public void readRmsVoltageMaxAttribute( + IntegerAttributeCallback callback + ) { readRmsVoltageMaxAttribute(chipClusterPtr, callback); } - public void subscribeRmsVoltageMaxAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsVoltageMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentAttribute(IntegerAttributeCallback callback) { + public void readRmsCurrentAttribute( + IntegerAttributeCallback callback + ) { readRmsCurrentAttribute(chipClusterPtr, callback); } - public void subscribeRmsCurrentAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentMinAttribute(IntegerAttributeCallback callback) { + public void readRmsCurrentMinAttribute( + IntegerAttributeCallback callback + ) { readRmsCurrentMinAttribute(chipClusterPtr, callback); } - public void subscribeRmsCurrentMinAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsCurrentMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentMaxAttribute(IntegerAttributeCallback callback) { + public void readRmsCurrentMaxAttribute( + IntegerAttributeCallback callback + ) { readRmsCurrentMaxAttribute(chipClusterPtr, callback); } - public void subscribeRmsCurrentMaxAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsCurrentMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerAttribute(IntegerAttributeCallback callback) { + public void readActivePowerAttribute( + IntegerAttributeCallback callback + ) { readActivePowerAttribute(chipClusterPtr, callback); } - public void subscribeActivePowerAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerMinAttribute(IntegerAttributeCallback callback) { + public void readActivePowerMinAttribute( + IntegerAttributeCallback callback + ) { readActivePowerMinAttribute(chipClusterPtr, callback); } - public void subscribeActivePowerMinAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActivePowerMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerMaxAttribute(IntegerAttributeCallback callback) { + public void readActivePowerMaxAttribute( + IntegerAttributeCallback callback + ) { readActivePowerMaxAttribute(chipClusterPtr, callback); } - public void subscribeActivePowerMaxAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActivePowerMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasurementTypeAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeMeasurementTypeAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTotalActivePowerAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTotalActivePowerAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsVoltageAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsVoltageAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsVoltageMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsVoltageMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsVoltageMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsVoltageMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsCurrentAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsCurrentAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsCurrentMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsCurrentMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsCurrentMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsCurrentMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActivePowerAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeActivePowerAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActivePowerMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeActivePowerMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActivePowerMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeActivePowerMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMeasurementTypeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeMeasurementTypeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTotalActivePowerAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTotalActivePowerAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class EthernetNetworkDiagnosticsCluster extends BaseChipCluster { @@ -5773,210 +5056,253 @@ public EthernetNetworkDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetCounts(DefaultClusterCallback callback) { + public void resetCounts(DefaultClusterCallback callback + ) { resetCounts(chipClusterPtr, callback, null); } - public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void resetCounts(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); - private native void resetCounts( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readPHYRateAttribute(IntegerAttributeCallback callback) { + public void readPHYRateAttribute( + IntegerAttributeCallback callback + ) { readPHYRateAttribute(chipClusterPtr, callback); } - public void subscribePHYRateAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePHYRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFullDuplexAttribute(BooleanAttributeCallback callback) { + public void readFullDuplexAttribute( + BooleanAttributeCallback callback + ) { readFullDuplexAttribute(chipClusterPtr, callback); } - public void subscribeFullDuplexAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFullDuplexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketRxCountAttribute(LongAttributeCallback callback) { + public void readPacketRxCountAttribute( + LongAttributeCallback callback + ) { readPacketRxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketRxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketTxCountAttribute(LongAttributeCallback callback) { + public void readPacketTxCountAttribute( + LongAttributeCallback callback + ) { readPacketTxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketTxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrCountAttribute(LongAttributeCallback callback) { + public void readTxErrCountAttribute( + LongAttributeCallback callback + ) { readTxErrCountAttribute(chipClusterPtr, callback); } - public void subscribeTxErrCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxErrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCollisionCountAttribute(LongAttributeCallback callback) { + public void readCollisionCountAttribute( + LongAttributeCallback callback + ) { readCollisionCountAttribute(chipClusterPtr, callback); } - public void subscribeCollisionCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCollisionCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute(LongAttributeCallback callback) { + public void readOverrunCountAttribute( + LongAttributeCallback callback + ) { readOverrunCountAttribute(chipClusterPtr, callback); } - public void subscribeOverrunCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCarrierDetectAttribute(BooleanAttributeCallback callback) { + public void readCarrierDetectAttribute( + BooleanAttributeCallback callback + ) { readCarrierDetectAttribute(chipClusterPtr, callback); } - public void subscribeCarrierDetectAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCarrierDetectAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTimeSinceResetAttribute(LongAttributeCallback callback) { + public void readTimeSinceResetAttribute( + LongAttributeCallback callback + ) { readTimeSinceResetAttribute(chipClusterPtr, callback); } - public void subscribeTimeSinceResetAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTimeSinceResetAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readPHYRateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePHYRateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readFullDuplexAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeFullDuplexAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxErrCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxErrCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCollisionCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeCollisionCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCarrierDetectAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeCarrierDetectAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTimeSinceResetAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTimeSinceResetAttribute( - long chipClusterPtr, LongAttributeCallback 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); + private native void readPHYRateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePHYRateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readFullDuplexAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeFullDuplexAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCollisionCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCollisionCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCarrierDetectAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeCarrierDetectAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTimeSinceResetAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTimeSinceResetAttribute(long chipClusterPtr, + LongAttributeCallback 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 FixedLabelCluster extends BaseChipCluster { @@ -5989,69 +5315,73 @@ public FixedLabelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LabelListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface LabelListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readLabelListAttribute(LabelListAttributeCallback callback) { + public void readLabelListAttribute( + LabelListAttributeCallback callback + ) { readLabelListAttribute(chipClusterPtr, callback); } - public void subscribeLabelListAttribute( - LabelListAttributeCallback callback, int minInterval, int maxInterval) { + LabelListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLabelListAttribute( - long chipClusterPtr, LabelListAttributeCallback callback); - - private native void subscribeLabelListAttribute( - long chipClusterPtr, LabelListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback callback + ); + private native void subscribeLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class FlowMeasurementCluster extends BaseChipCluster { @@ -6064,106 +5394,125 @@ public FlowMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMinMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMaxMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute(IntegerAttributeCallback callback) { + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { readToleranceAttribute(chipClusterPtr, callback); } - public void subscribeToleranceAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class GeneralCommissioningCluster extends BaseChipCluster { @@ -6176,235 +5525,199 @@ public GeneralCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void armFailSafe( - ArmFailSafeResponseCallback callback, - Integer expiryLengthSeconds, - Long breadcrumb, - Long timeoutMs) { + public void armFailSafe(ArmFailSafeResponseCallback callback + , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs) { armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timeoutMs, null); } - public void armFailSafe( - ArmFailSafeResponseCallback callback, - Integer expiryLengthSeconds, - Long breadcrumb, - Long timeoutMs, - int timedInvokeTimeoutMs) { - armFailSafe( - chipClusterPtr, - callback, - expiryLengthSeconds, - breadcrumb, - timeoutMs, - timedInvokeTimeoutMs); + public void armFailSafe(ArmFailSafeResponseCallback callback + , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs + , int timedInvokeTimeoutMs) { + armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timeoutMs, timedInvokeTimeoutMs); } - public void commissioningComplete(CommissioningCompleteResponseCallback callback) { + public void commissioningComplete(CommissioningCompleteResponseCallback callback + ) { commissioningComplete(chipClusterPtr, callback, null); } - public void commissioningComplete( - CommissioningCompleteResponseCallback callback, int timedInvokeTimeoutMs) { - + public void commissioningComplete(CommissioningCompleteResponseCallback callback + + , int timedInvokeTimeoutMs) { commissioningComplete(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void setRegulatoryConfig( - SetRegulatoryConfigResponseCallback callback, - Integer location, - String countryCode, - Long breadcrumb, - Long timeoutMs) { - setRegulatoryConfig( - chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, null); - } - - public void setRegulatoryConfig( - SetRegulatoryConfigResponseCallback callback, - Integer location, - String countryCode, - Long breadcrumb, - Long timeoutMs, - int timedInvokeTimeoutMs) { - setRegulatoryConfig( - chipClusterPtr, - callback, - location, - countryCode, - breadcrumb, - timeoutMs, - timedInvokeTimeoutMs); - } - - private native void armFailSafe( - long chipClusterPtr, - ArmFailSafeResponseCallback Callback, - Integer expiryLengthSeconds, - Long breadcrumb, - Long timeoutMs, - @Nullable Integer timedInvokeTimeoutMs); - - private native void commissioningComplete( - long chipClusterPtr, - CommissioningCompleteResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setRegulatoryConfig( - long chipClusterPtr, - SetRegulatoryConfigResponseCallback Callback, - Integer location, - String countryCode, - Long breadcrumb, - Long timeoutMs, - @Nullable Integer timedInvokeTimeoutMs); + public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback + , Integer location, String countryCode, Long breadcrumb, Long timeoutMs) { + setRegulatoryConfig(chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, null); + } + public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback + , Integer location, String countryCode, Long breadcrumb, Long timeoutMs + , int timedInvokeTimeoutMs) { + setRegulatoryConfig(chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, timedInvokeTimeoutMs); + } + private native void armFailSafe(long chipClusterPtr, ArmFailSafeResponseCallback Callback + , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs + , @Nullable Integer timedInvokeTimeoutMs); + private native void commissioningComplete(long chipClusterPtr, CommissioningCompleteResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void setRegulatoryConfig(long chipClusterPtr, SetRegulatoryConfigResponseCallback Callback + , Integer location, String countryCode, Long breadcrumb, Long timeoutMs + , @Nullable Integer timedInvokeTimeoutMs); public interface ArmFailSafeResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } public interface CommissioningCompleteResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } public interface SetRegulatoryConfigResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } - public interface BasicCommissioningInfoListAttributeCallback { - void onSuccess( - List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface BasicCommissioningInfoListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readBreadcrumbAttribute(LongAttributeCallback callback) { + public void readBreadcrumbAttribute( + LongAttributeCallback callback + ) { readBreadcrumbAttribute(chipClusterPtr, callback); } - public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value) { writeBreadcrumbAttribute(chipClusterPtr, callback, value, null); } - public void writeBreadcrumbAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBreadcrumbAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBreadcrumbAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBreadcrumbAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readBasicCommissioningInfoListAttribute( - BasicCommissioningInfoListAttributeCallback callback) { + BasicCommissioningInfoListAttributeCallback callback + ) { readBasicCommissioningInfoListAttribute(chipClusterPtr, callback); } - public void subscribeBasicCommissioningInfoListAttribute( - BasicCommissioningInfoListAttributeCallback callback, int minInterval, int maxInterval) { - subscribeBasicCommissioningInfoListAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + BasicCommissioningInfoListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBasicCommissioningInfoListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRegulatoryConfigAttribute(IntegerAttributeCallback callback) { + public void readRegulatoryConfigAttribute( + IntegerAttributeCallback callback + ) { readRegulatoryConfigAttribute(chipClusterPtr, callback); } - public void subscribeRegulatoryConfigAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRegulatoryConfigAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocationCapabilityAttribute(IntegerAttributeCallback callback) { + public void readLocationCapabilityAttribute( + IntegerAttributeCallback callback + ) { readLocationCapabilityAttribute(chipClusterPtr, callback); } - public void subscribeLocationCapabilityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLocationCapabilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBreadcrumbAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void writeBreadcrumbAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBreadcrumbAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBasicCommissioningInfoListAttribute( - long chipClusterPtr, BasicCommissioningInfoListAttributeCallback callback); - - private native void subscribeBasicCommissioningInfoListAttribute( - long chipClusterPtr, - BasicCommissioningInfoListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readRegulatoryConfigAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRegulatoryConfigAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLocationCapabilityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLocationCapabilityAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readBreadcrumbAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeBreadcrumbAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBreadcrumbAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBasicCommissioningInfoListAttribute(long chipClusterPtr, + BasicCommissioningInfoListAttributeCallback callback + ); + private native void subscribeBasicCommissioningInfoListAttribute(long chipClusterPtr, + BasicCommissioningInfoListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRegulatoryConfigAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRegulatoryConfigAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLocationCapabilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLocationCapabilityAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class GeneralDiagnosticsCluster extends BaseChipCluster { @@ -6417,209 +5730,221 @@ public GeneralDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface NetworkInterfacesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); + public interface NetworkInterfacesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ActiveHardwareFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ActiveRadioFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ActiveNetworkFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - default void onSubscriptionEstablished() {} + public void readNetworkInterfacesAttribute( + NetworkInterfacesAttributeCallback callback + ) { + readNetworkInterfacesAttribute(chipClusterPtr, callback); + } + public void subscribeNetworkInterfacesAttribute( + NetworkInterfacesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public interface ActiveHardwareFaultsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ActiveRadioFaultsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ActiveNetworkFaultsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readNetworkInterfacesAttribute(NetworkInterfacesAttributeCallback callback) { - readNetworkInterfacesAttribute(chipClusterPtr, callback); - } - - public void subscribeNetworkInterfacesAttribute( - NetworkInterfacesAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readRebootCountAttribute(IntegerAttributeCallback callback) { + public void readRebootCountAttribute( + IntegerAttributeCallback callback + ) { readRebootCountAttribute(chipClusterPtr, callback); } - public void subscribeRebootCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRebootCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpTimeAttribute(LongAttributeCallback callback) { + public void readUpTimeAttribute( + LongAttributeCallback callback + ) { readUpTimeAttribute(chipClusterPtr, callback); } - public void subscribeUpTimeAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeUpTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTotalOperationalHoursAttribute(LongAttributeCallback callback) { + public void readTotalOperationalHoursAttribute( + LongAttributeCallback callback + ) { readTotalOperationalHoursAttribute(chipClusterPtr, callback); } - public void subscribeTotalOperationalHoursAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTotalOperationalHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBootReasonsAttribute(IntegerAttributeCallback callback) { + public void readBootReasonsAttribute( + IntegerAttributeCallback callback + ) { readBootReasonsAttribute(chipClusterPtr, callback); } - public void subscribeBootReasonsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBootReasonsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveHardwareFaultsAttribute(ActiveHardwareFaultsAttributeCallback callback) { + public void readActiveHardwareFaultsAttribute( + ActiveHardwareFaultsAttributeCallback callback + ) { readActiveHardwareFaultsAttribute(chipClusterPtr, callback); } - public void subscribeActiveHardwareFaultsAttribute( - ActiveHardwareFaultsAttributeCallback callback, int minInterval, int maxInterval) { + ActiveHardwareFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeActiveHardwareFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveRadioFaultsAttribute(ActiveRadioFaultsAttributeCallback callback) { + public void readActiveRadioFaultsAttribute( + ActiveRadioFaultsAttributeCallback callback + ) { readActiveRadioFaultsAttribute(chipClusterPtr, callback); } - public void subscribeActiveRadioFaultsAttribute( - ActiveRadioFaultsAttributeCallback callback, int minInterval, int maxInterval) { + ActiveRadioFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeActiveRadioFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveNetworkFaultsAttribute(ActiveNetworkFaultsAttributeCallback callback) { + public void readActiveNetworkFaultsAttribute( + ActiveNetworkFaultsAttributeCallback callback + ) { readActiveNetworkFaultsAttribute(chipClusterPtr, callback); } - public void subscribeActiveNetworkFaultsAttribute( - ActiveNetworkFaultsAttributeCallback callback, int minInterval, int maxInterval) { + ActiveNetworkFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeActiveNetworkFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNetworkInterfacesAttribute( - long chipClusterPtr, NetworkInterfacesAttributeCallback callback); - - private native void subscribeNetworkInterfacesAttribute( - long chipClusterPtr, - NetworkInterfacesAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readRebootCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRebootCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readUpTimeAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeUpTimeAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTotalOperationalHoursAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTotalOperationalHoursAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBootReasonsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBootReasonsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActiveHardwareFaultsAttribute( - long chipClusterPtr, ActiveHardwareFaultsAttributeCallback callback); - - private native void subscribeActiveHardwareFaultsAttribute( - long chipClusterPtr, - ActiveHardwareFaultsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readActiveRadioFaultsAttribute( - long chipClusterPtr, ActiveRadioFaultsAttributeCallback callback); - - private native void subscribeActiveRadioFaultsAttribute( - long chipClusterPtr, - ActiveRadioFaultsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readActiveNetworkFaultsAttribute( - long chipClusterPtr, ActiveNetworkFaultsAttributeCallback callback); - - private native void subscribeActiveNetworkFaultsAttribute( - long chipClusterPtr, - ActiveNetworkFaultsAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readNetworkInterfacesAttribute(long chipClusterPtr, + NetworkInterfacesAttributeCallback callback + ); + private native void subscribeNetworkInterfacesAttribute(long chipClusterPtr, + NetworkInterfacesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRebootCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRebootCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUpTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeUpTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTotalOperationalHoursAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTotalOperationalHoursAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBootReasonsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBootReasonsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveHardwareFaultsAttribute(long chipClusterPtr, + ActiveHardwareFaultsAttributeCallback callback + ); + private native void subscribeActiveHardwareFaultsAttribute(long chipClusterPtr, + ActiveHardwareFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readActiveRadioFaultsAttribute(long chipClusterPtr, + ActiveRadioFaultsAttributeCallback callback + ); + private native void subscribeActiveRadioFaultsAttribute(long chipClusterPtr, + ActiveRadioFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readActiveNetworkFaultsAttribute(long chipClusterPtr, + ActiveNetworkFaultsAttributeCallback callback + ); + private native void subscribeActiveNetworkFaultsAttribute(long chipClusterPtr, + ActiveNetworkFaultsAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class GroupKeyManagementCluster extends BaseChipCluster { @@ -6632,207 +5957,203 @@ public GroupKeyManagementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void keySetRead(KeySetReadResponseCallback callback, Integer groupKeySetID) { + public void keySetRead(KeySetReadResponseCallback callback + , Integer groupKeySetID) { keySetRead(chipClusterPtr, callback, groupKeySetID, null); } - public void keySetRead( - KeySetReadResponseCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) { + public void keySetRead(KeySetReadResponseCallback callback + , Integer groupKeySetID + , int timedInvokeTimeoutMs) { keySetRead(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); } - public void keySetReadAllIndices( - KeySetReadAllIndicesResponseCallback callback, ArrayList groupKeySetIDs) { + public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback + , ArrayList groupKeySetIDs) { keySetReadAllIndices(chipClusterPtr, callback, groupKeySetIDs, null); } - public void keySetReadAllIndices( - KeySetReadAllIndicesResponseCallback callback, - ArrayList groupKeySetIDs, - int timedInvokeTimeoutMs) { + public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback + , ArrayList groupKeySetIDs + , int timedInvokeTimeoutMs) { keySetReadAllIndices(chipClusterPtr, callback, groupKeySetIDs, timedInvokeTimeoutMs); } - public void keySetRemove(DefaultClusterCallback callback, Integer groupKeySetID) { + public void keySetRemove(DefaultClusterCallback callback + , Integer groupKeySetID) { keySetRemove(chipClusterPtr, callback, groupKeySetID, null); } - public void keySetRemove( - DefaultClusterCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) { + public void keySetRemove(DefaultClusterCallback callback + , Integer groupKeySetID + , int timedInvokeTimeoutMs) { keySetRemove(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); } - public void keySetWrite( - DefaultClusterCallback callback, - ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { + public void keySetWrite(DefaultClusterCallback callback + , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { keySetWrite(chipClusterPtr, callback, groupKeySet, null); } - public void keySetWrite( - DefaultClusterCallback callback, - ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet, - int timedInvokeTimeoutMs) { + public void keySetWrite(DefaultClusterCallback callback + , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet + , int timedInvokeTimeoutMs) { keySetWrite(chipClusterPtr, callback, groupKeySet, timedInvokeTimeoutMs); } - - private native void keySetRead( - long chipClusterPtr, - KeySetReadResponseCallback Callback, - Integer groupKeySetID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void keySetReadAllIndices( - long chipClusterPtr, - KeySetReadAllIndicesResponseCallback Callback, - ArrayList groupKeySetIDs, - @Nullable Integer timedInvokeTimeoutMs); - - private native void keySetRemove( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer groupKeySetID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void keySetWrite( - long chipClusterPtr, - DefaultClusterCallback Callback, - ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet, - @Nullable Integer timedInvokeTimeoutMs); - + private native void keySetRead(long chipClusterPtr, KeySetReadResponseCallback Callback + , Integer groupKeySetID + , @Nullable Integer timedInvokeTimeoutMs); + private native void keySetReadAllIndices(long chipClusterPtr, KeySetReadAllIndicesResponseCallback Callback + , ArrayList groupKeySetIDs + , @Nullable Integer timedInvokeTimeoutMs); + private native void keySetRemove(long chipClusterPtr, DefaultClusterCallback Callback + , Integer groupKeySetID + , @Nullable Integer timedInvokeTimeoutMs); + private native void keySetWrite(long chipClusterPtr, DefaultClusterCallback Callback + , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet + , @Nullable Integer timedInvokeTimeoutMs); public interface KeySetReadAllIndicesResponseCallback { void onSuccess(ArrayList groupKeySetIDs); - + void onError(Exception error); } public interface KeySetReadResponseCallback { void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet); - + void onError(Exception error); } - public interface GroupKeyMapAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface GroupTableAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface GroupKeyMapAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface GroupTableAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readGroupKeyMapAttribute(GroupKeyMapAttributeCallback callback) { + public void readGroupKeyMapAttribute( + GroupKeyMapAttributeCallback callback + ) { readGroupKeyMapAttribute(chipClusterPtr, callback); } - public void subscribeGroupKeyMapAttribute( - GroupKeyMapAttributeCallback callback, int minInterval, int maxInterval) { + GroupKeyMapAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeGroupKeyMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGroupTableAttribute(GroupTableAttributeCallback callback) { + public void readGroupTableAttribute( + GroupTableAttributeCallback callback + ) { readGroupTableAttribute(chipClusterPtr, callback); } - public void subscribeGroupTableAttribute( - GroupTableAttributeCallback callback, int minInterval, int maxInterval) { + GroupTableAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeGroupTableAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxGroupsPerFabricAttribute(IntegerAttributeCallback callback) { + public void readMaxGroupsPerFabricAttribute( + IntegerAttributeCallback callback + ) { readMaxGroupsPerFabricAttribute(chipClusterPtr, callback); } - public void subscribeMaxGroupsPerFabricAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxGroupsPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxGroupKeysPerFabricAttribute(IntegerAttributeCallback callback) { + public void readMaxGroupKeysPerFabricAttribute( + IntegerAttributeCallback callback + ) { readMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback); } - public void subscribeMaxGroupKeysPerFabricAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readGroupKeyMapAttribute( - long chipClusterPtr, GroupKeyMapAttributeCallback callback); - - private native void subscribeGroupKeyMapAttribute( - long chipClusterPtr, - GroupKeyMapAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readGroupTableAttribute( - long chipClusterPtr, GroupTableAttributeCallback callback); - - private native void subscribeGroupTableAttribute( - long chipClusterPtr, - GroupTableAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readMaxGroupsPerFabricAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxGroupsPerFabricAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxGroupKeysPerFabricAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxGroupKeysPerFabricAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readGroupKeyMapAttribute(long chipClusterPtr, + GroupKeyMapAttributeCallback callback + ); + private native void subscribeGroupKeyMapAttribute(long chipClusterPtr, + GroupKeyMapAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGroupTableAttribute(long chipClusterPtr, + GroupTableAttributeCallback callback + ); + private native void subscribeGroupTableAttribute(long chipClusterPtr, + GroupTableAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxGroupsPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxGroupsPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxGroupKeysPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxGroupKeysPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class GroupsCluster extends BaseChipCluster { @@ -6845,186 +6166,176 @@ public GroupsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addGroup(AddGroupResponseCallback callback, Integer groupId, String groupName) { + public void addGroup(AddGroupResponseCallback callback + , Integer groupId, String groupName) { addGroup(chipClusterPtr, callback, groupId, groupName, null); } - public void addGroup( - AddGroupResponseCallback callback, - Integer groupId, - String groupName, - int timedInvokeTimeoutMs) { + public void addGroup(AddGroupResponseCallback callback + , Integer groupId, String groupName + , int timedInvokeTimeoutMs) { addGroup(chipClusterPtr, callback, groupId, groupName, timedInvokeTimeoutMs); } - public void addGroupIfIdentifying( - DefaultClusterCallback callback, Integer groupId, String groupName) { + public void addGroupIfIdentifying(DefaultClusterCallback callback + , Integer groupId, String groupName) { addGroupIfIdentifying(chipClusterPtr, callback, groupId, groupName, null); } - public void addGroupIfIdentifying( - DefaultClusterCallback callback, - Integer groupId, - String groupName, - int timedInvokeTimeoutMs) { + public void addGroupIfIdentifying(DefaultClusterCallback callback + , Integer groupId, String groupName + , int timedInvokeTimeoutMs) { addGroupIfIdentifying(chipClusterPtr, callback, groupId, groupName, timedInvokeTimeoutMs); } - public void getGroupMembership( - GetGroupMembershipResponseCallback callback, ArrayList groupList) { + public void getGroupMembership(GetGroupMembershipResponseCallback callback + , ArrayList groupList) { getGroupMembership(chipClusterPtr, callback, groupList, null); } - public void getGroupMembership( - GetGroupMembershipResponseCallback callback, - ArrayList groupList, - int timedInvokeTimeoutMs) { + public void getGroupMembership(GetGroupMembershipResponseCallback callback + , ArrayList groupList + , int timedInvokeTimeoutMs) { getGroupMembership(chipClusterPtr, callback, groupList, timedInvokeTimeoutMs); } - public void removeAllGroups(DefaultClusterCallback callback) { + public void removeAllGroups(DefaultClusterCallback callback + ) { removeAllGroups(chipClusterPtr, callback, null); } - public void removeAllGroups(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void removeAllGroups(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { removeAllGroups(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void removeGroup(RemoveGroupResponseCallback callback, Integer groupId) { + public void removeGroup(RemoveGroupResponseCallback callback + , Integer groupId) { removeGroup(chipClusterPtr, callback, groupId, null); } - public void removeGroup( - RemoveGroupResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { + public void removeGroup(RemoveGroupResponseCallback callback + , Integer groupId + , int timedInvokeTimeoutMs) { removeGroup(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void viewGroup(ViewGroupResponseCallback callback, Integer groupId) { + public void viewGroup(ViewGroupResponseCallback callback + , Integer groupId) { viewGroup(chipClusterPtr, callback, groupId, null); } - public void viewGroup( - ViewGroupResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { + public void viewGroup(ViewGroupResponseCallback callback + , Integer groupId + , int timedInvokeTimeoutMs) { viewGroup(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - - private native void addGroup( - long chipClusterPtr, - AddGroupResponseCallback Callback, - Integer groupId, - String groupName, - @Nullable Integer timedInvokeTimeoutMs); - - private native void addGroupIfIdentifying( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer groupId, - String groupName, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getGroupMembership( - long chipClusterPtr, - GetGroupMembershipResponseCallback Callback, - ArrayList groupList, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeAllGroups( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeGroup( - long chipClusterPtr, - RemoveGroupResponseCallback Callback, - Integer groupId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void viewGroup( - long chipClusterPtr, - ViewGroupResponseCallback Callback, - Integer groupId, - @Nullable Integer timedInvokeTimeoutMs); - + private native void addGroup(long chipClusterPtr, AddGroupResponseCallback Callback + , Integer groupId, String groupName + , @Nullable Integer timedInvokeTimeoutMs); + private native void addGroupIfIdentifying(long chipClusterPtr, DefaultClusterCallback Callback + , Integer groupId, String groupName + , @Nullable Integer timedInvokeTimeoutMs); + private native void getGroupMembership(long chipClusterPtr, GetGroupMembershipResponseCallback Callback + , ArrayList groupList + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeAllGroups(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeGroup(long chipClusterPtr, RemoveGroupResponseCallback Callback + , Integer groupId + , @Nullable Integer timedInvokeTimeoutMs); + private native void viewGroup(long chipClusterPtr, ViewGroupResponseCallback Callback + , Integer groupId + , @Nullable Integer timedInvokeTimeoutMs); public interface AddGroupResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface GetGroupMembershipResponseCallback { void onSuccess(Integer capacity, ArrayList groupList); - + void onError(Exception error); } public interface RemoveGroupResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface ViewGroupResponseCallback { void onSuccess(Integer status, Integer groupId, String groupName); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readNameSupportAttribute(IntegerAttributeCallback callback) { + public void readNameSupportAttribute( + IntegerAttributeCallback callback + ) { readNameSupportAttribute(chipClusterPtr, callback); } - public void subscribeNameSupportAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNameSupportAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNameSupportAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class IdentifyCluster extends BaseChipCluster { @@ -7037,147 +6348,144 @@ public IdentifyCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void identify(DefaultClusterCallback callback, Integer identifyTime) { + public void identify(DefaultClusterCallback callback + , Integer identifyTime) { identify(chipClusterPtr, callback, identifyTime, null); } - public void identify( - DefaultClusterCallback callback, Integer identifyTime, int timedInvokeTimeoutMs) { + public void identify(DefaultClusterCallback callback + , Integer identifyTime + , int timedInvokeTimeoutMs) { identify(chipClusterPtr, callback, identifyTime, timedInvokeTimeoutMs); } - public void identifyQuery(IdentifyQueryResponseCallback callback) { + public void identifyQuery(IdentifyQueryResponseCallback callback + ) { identifyQuery(chipClusterPtr, callback, null); } - public void identifyQuery(IdentifyQueryResponseCallback callback, int timedInvokeTimeoutMs) { - + public void identifyQuery(IdentifyQueryResponseCallback callback + + , int timedInvokeTimeoutMs) { identifyQuery(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void triggerEffect( - DefaultClusterCallback callback, Integer effectIdentifier, Integer effectVariant) { + public void triggerEffect(DefaultClusterCallback callback + , Integer effectIdentifier, Integer effectVariant) { triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, null); } - public void triggerEffect( - DefaultClusterCallback callback, - Integer effectIdentifier, - Integer effectVariant, - int timedInvokeTimeoutMs) { - triggerEffect( - chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); - } - - private native void identify( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer identifyTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void identifyQuery( - long chipClusterPtr, - IdentifyQueryResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void triggerEffect( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer effectIdentifier, - Integer effectVariant, - @Nullable Integer timedInvokeTimeoutMs); - + public void triggerEffect(DefaultClusterCallback callback + , Integer effectIdentifier, Integer effectVariant + , int timedInvokeTimeoutMs) { + triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); + } + private native void identify(long chipClusterPtr, DefaultClusterCallback Callback + , Integer identifyTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void identifyQuery(long chipClusterPtr, IdentifyQueryResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void triggerEffect(long chipClusterPtr, DefaultClusterCallback Callback + , Integer effectIdentifier, Integer effectVariant + , @Nullable Integer timedInvokeTimeoutMs); public interface IdentifyQueryResponseCallback { void onSuccess(Integer timeout); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readIdentifyTimeAttribute(IntegerAttributeCallback callback) { + public void readIdentifyTimeAttribute( + IntegerAttributeCallback callback + ) { readIdentifyTimeAttribute(chipClusterPtr, callback); } - public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value) { writeIdentifyTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeIdentifyTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeIdentifyTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeIdentifyTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeIdentifyTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readIdentifyTypeAttribute(IntegerAttributeCallback callback) { + public void readIdentifyTypeAttribute( + IntegerAttributeCallback callback + ) { readIdentifyTypeAttribute(chipClusterPtr, callback); } - public void subscribeIdentifyTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeIdentifyTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readIdentifyTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeIdentifyTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeIdentifyTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readIdentifyTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeIdentifyTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readIdentifyTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeIdentifyTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeIdentifyTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readIdentifyTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeIdentifyTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class IlluminanceMeasurementCluster extends BaseChipCluster { @@ -7190,165 +6498,164 @@ public IlluminanceMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface MeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface MinMeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface MaxMeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface LightSensorTypeAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface LightSensorTypeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute(MeasuredValueAttributeCallback callback) { + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { readMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMeasuredValueAttribute( - MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute(MinMeasuredValueAttributeCallback callback) { + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMinMeasuredValueAttribute( - MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute(MaxMeasuredValueAttributeCallback callback) { + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMaxMeasuredValueAttribute( - MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute(IntegerAttributeCallback callback) { + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { readToleranceAttribute(chipClusterPtr, callback); } - public void subscribeToleranceAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLightSensorTypeAttribute(LightSensorTypeAttributeCallback callback) { + public void readLightSensorTypeAttribute( + LightSensorTypeAttributeCallback callback + ) { readLightSensorTypeAttribute(chipClusterPtr, callback); } - public void subscribeLightSensorTypeAttribute( - LightSensorTypeAttributeCallback callback, int minInterval, int maxInterval) { + LightSensorTypeAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLightSensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute( - long chipClusterPtr, MeasuredValueAttributeCallback callback); - - private native void subscribeMeasuredValueAttribute( - long chipClusterPtr, - MeasuredValueAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readMinMeasuredValueAttribute( - long chipClusterPtr, MinMeasuredValueAttributeCallback callback); - - private native void subscribeMinMeasuredValueAttribute( - long chipClusterPtr, - MinMeasuredValueAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readMaxMeasuredValueAttribute( - long chipClusterPtr, MaxMeasuredValueAttributeCallback callback); - - private native void subscribeMaxMeasuredValueAttribute( - long chipClusterPtr, - MaxMeasuredValueAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLightSensorTypeAttribute( - long chipClusterPtr, LightSensorTypeAttributeCallback callback); - - private native void subscribeLightSensorTypeAttribute( - long chipClusterPtr, - LightSensorTypeAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLightSensorTypeAttribute(long chipClusterPtr, + LightSensorTypeAttributeCallback callback + ); + private native void subscribeLightSensorTypeAttribute(long chipClusterPtr, + LightSensorTypeAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class KeypadInputCluster extends BaseChipCluster { @@ -7361,67 +6668,69 @@ public KeypadInputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void sendKeyRequest(SendKeyResponseCallback callback, Integer keyCode) { + public void sendKeyRequest(SendKeyResponseCallback callback + , Integer keyCode) { sendKeyRequest(chipClusterPtr, callback, keyCode, null); } - public void sendKeyRequest( - SendKeyResponseCallback callback, Integer keyCode, int timedInvokeTimeoutMs) { + public void sendKeyRequest(SendKeyResponseCallback callback + , Integer keyCode + , int timedInvokeTimeoutMs) { sendKeyRequest(chipClusterPtr, callback, keyCode, timedInvokeTimeoutMs); } - - private native void sendKeyRequest( - long chipClusterPtr, - SendKeyResponseCallback Callback, - Integer keyCode, - @Nullable Integer timedInvokeTimeoutMs); - + private native void sendKeyRequest(long chipClusterPtr, SendKeyResponseCallback Callback + , Integer keyCode + , @Nullable Integer timedInvokeTimeoutMs); public interface SendKeyResponseCallback { void onSuccess(Integer status); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 LevelControlCluster extends BaseChipCluster { @@ -7434,642 +6743,535 @@ public LevelControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void move( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionMask, - Integer optionOverride) { + public void move(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride) { move(chipClusterPtr, callback, moveMode, rate, optionMask, optionOverride, null); } - public void move( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionMask, - Integer optionOverride, - int timedInvokeTimeoutMs) { - move( - chipClusterPtr, - callback, - moveMode, - rate, - optionMask, - optionOverride, - timedInvokeTimeoutMs); - } - - public void moveToLevel( - DefaultClusterCallback callback, - Integer level, - Integer transitionTime, - Integer optionMask, - Integer optionOverride) { - moveToLevel( - chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, null); - } - - public void moveToLevel( - DefaultClusterCallback callback, - Integer level, - Integer transitionTime, - Integer optionMask, - Integer optionOverride, - int timedInvokeTimeoutMs) { - moveToLevel( - chipClusterPtr, - callback, - level, - transitionTime, - optionMask, - optionOverride, - timedInvokeTimeoutMs); - } - - public void moveToLevelWithOnOff( - DefaultClusterCallback callback, Integer level, Integer transitionTime) { - moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, null); - } - - public void moveToLevelWithOnOff( - DefaultClusterCallback callback, - Integer level, - Integer transitionTime, - int timedInvokeTimeoutMs) { - moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, timedInvokeTimeoutMs); + public void move(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride + , int timedInvokeTimeoutMs) { + move(chipClusterPtr, callback, moveMode, rate, optionMask, optionOverride, timedInvokeTimeoutMs); } - public void moveWithOnOff(DefaultClusterCallback callback, Integer moveMode, Integer rate) { - moveWithOnOff(chipClusterPtr, callback, moveMode, rate, null); + public void moveToLevel(DefaultClusterCallback callback + , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride) { + moveToLevel(chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, null); } - public void moveWithOnOff( - DefaultClusterCallback callback, Integer moveMode, Integer rate, int timedInvokeTimeoutMs) { - moveWithOnOff(chipClusterPtr, callback, moveMode, rate, timedInvokeTimeoutMs); + public void moveToLevel(DefaultClusterCallback callback + , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride + , int timedInvokeTimeoutMs) { + moveToLevel(chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, timedInvokeTimeoutMs); } - public void step( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionMask, - Integer optionOverride) { - step( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionMask, - optionOverride, - null); - } - - public void step( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionMask, - Integer optionOverride, - int timedInvokeTimeoutMs) { - step( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionMask, - optionOverride, - timedInvokeTimeoutMs); - } - - public void stepWithOnOff( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime) { - stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, null); + public void moveToLevelWithOnOff(DefaultClusterCallback callback + , Integer level, Integer transitionTime) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, null); } - public void stepWithOnOff( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - int timedInvokeTimeoutMs) { - stepWithOnOff( - chipClusterPtr, callback, stepMode, stepSize, transitionTime, timedInvokeTimeoutMs); + public void moveToLevelWithOnOff(DefaultClusterCallback callback + , Integer level, Integer transitionTime + , int timedInvokeTimeoutMs) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, timedInvokeTimeoutMs); } - public void stop(DefaultClusterCallback callback, Integer optionMask, Integer optionOverride) { - stop(chipClusterPtr, callback, optionMask, optionOverride, null); + public void moveWithOnOff(DefaultClusterCallback callback + , Integer moveMode, Integer rate) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, null); } - public void stop( - DefaultClusterCallback callback, - Integer optionMask, - Integer optionOverride, - int timedInvokeTimeoutMs) { - stop(chipClusterPtr, callback, optionMask, optionOverride, timedInvokeTimeoutMs); + public void moveWithOnOff(DefaultClusterCallback callback + , Integer moveMode, Integer rate + , int timedInvokeTimeoutMs) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, timedInvokeTimeoutMs); } - public void stopWithOnOff(DefaultClusterCallback callback) { - stopWithOnOff(chipClusterPtr, callback, null); + public void step(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride) { + step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionMask, optionOverride, null); } - public void stopWithOnOff(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); + public void step(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride + , int timedInvokeTimeoutMs) { + step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionMask, optionOverride, timedInvokeTimeoutMs); } - private native void move( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - Integer optionMask, - Integer optionOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToLevel( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer level, - Integer transitionTime, - Integer optionMask, - Integer optionOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToLevelWithOnOff( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer level, - Integer transitionTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveWithOnOff( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - @Nullable Integer timedInvokeTimeoutMs); - - private native void step( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionMask, - Integer optionOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stepWithOnOff( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stop( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer optionMask, - Integer optionOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopWithOnOff( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface OnLevelAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stepWithOnOff(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime) { + stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, null); } - public interface OnTransitionTimeAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stepWithOnOff(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime + , int timedInvokeTimeoutMs) { + stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, timedInvokeTimeoutMs); } - public interface OffTransitionTimeAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stop(DefaultClusterCallback callback + , Integer optionMask, Integer optionOverride) { + stop(chipClusterPtr, callback, optionMask, optionOverride, null); } - public interface DefaultMoveRateAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stop(DefaultClusterCallback callback + , Integer optionMask, Integer optionOverride + , int timedInvokeTimeoutMs) { + stop(chipClusterPtr, callback, optionMask, optionOverride, timedInvokeTimeoutMs); } - public interface StartUpCurrentLevelAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stopWithOnOff(DefaultClusterCallback callback + ) { + stopWithOnOff(chipClusterPtr, callback, null); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stopWithOnOff(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void move(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToLevel(long chipClusterPtr, DefaultClusterCallback Callback + , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToLevelWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer level, Integer transitionTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate + , @Nullable Integer timedInvokeTimeoutMs); + private native void step(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void stop(long chipClusterPtr, DefaultClusterCallback Callback + , Integer optionMask, Integer optionOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface OnLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface OnTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface OffTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface DefaultMoveRateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface StartUpCurrentLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readCurrentLevelAttribute(IntegerAttributeCallback callback) { + public void readCurrentLevelAttribute( + IntegerAttributeCallback callback + ) { readCurrentLevelAttribute(chipClusterPtr, callback); } - public void subscribeCurrentLevelAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRemainingTimeAttribute(IntegerAttributeCallback callback) { + public void readRemainingTimeAttribute( + IntegerAttributeCallback callback + ) { readRemainingTimeAttribute(chipClusterPtr, callback); } - public void subscribeRemainingTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinLevelAttribute(IntegerAttributeCallback callback) { + public void readMinLevelAttribute( + IntegerAttributeCallback callback + ) { readMinLevelAttribute(chipClusterPtr, callback); } - public void subscribeMinLevelAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxLevelAttribute(IntegerAttributeCallback callback) { + public void readMaxLevelAttribute( + IntegerAttributeCallback callback + ) { readMaxLevelAttribute(chipClusterPtr, callback); } - public void subscribeMaxLevelAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentFrequencyAttribute(IntegerAttributeCallback callback) { + public void readCurrentFrequencyAttribute( + IntegerAttributeCallback callback + ) { readCurrentFrequencyAttribute(chipClusterPtr, callback); } - public void subscribeCurrentFrequencyAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinFrequencyAttribute(IntegerAttributeCallback callback) { + public void readMinFrequencyAttribute( + IntegerAttributeCallback callback + ) { readMinFrequencyAttribute(chipClusterPtr, callback); } - public void subscribeMinFrequencyAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxFrequencyAttribute(IntegerAttributeCallback callback) { + public void readMaxFrequencyAttribute( + IntegerAttributeCallback callback + ) { readMaxFrequencyAttribute(chipClusterPtr, callback); } - public void subscribeMaxFrequencyAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOptionsAttribute(IntegerAttributeCallback callback) { + public void readOptionsAttribute( + IntegerAttributeCallback callback + ) { readOptionsAttribute(chipClusterPtr, callback); } - public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value) { writeOptionsAttribute(chipClusterPtr, callback, value, null); } - public void writeOptionsAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOptionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnOffTransitionTimeAttribute(IntegerAttributeCallback callback) { + public void readOnOffTransitionTimeAttribute( + IntegerAttributeCallback callback + ) { readOnOffTransitionTimeAttribute(chipClusterPtr, callback); } - public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnOffTransitionTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOnOffTransitionTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOnOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnLevelAttribute(OnLevelAttributeCallback callback) { + public void readOnLevelAttribute( + OnLevelAttributeCallback callback + ) { readOnLevelAttribute(chipClusterPtr, callback); } - public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value) { writeOnLevelAttribute(chipClusterPtr, callback, value, null); } - public void writeOnLevelAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOnLevelAttribute( - OnLevelAttributeCallback callback, int minInterval, int maxInterval) { + OnLevelAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeOnLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnTransitionTimeAttribute(OnTransitionTimeAttributeCallback callback) { + public void readOnTransitionTimeAttribute( + OnTransitionTimeAttributeCallback callback + ) { readOnTransitionTimeAttribute(chipClusterPtr, callback); } - public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnTransitionTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOnTransitionTimeAttribute( - OnTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) { + OnTransitionTimeAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeOnTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOffTransitionTimeAttribute(OffTransitionTimeAttributeCallback callback) { + public void readOffTransitionTimeAttribute( + OffTransitionTimeAttributeCallback callback + ) { readOffTransitionTimeAttribute(chipClusterPtr, callback); } - public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOffTransitionTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOffTransitionTimeAttribute( - OffTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) { + OffTransitionTimeAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDefaultMoveRateAttribute(DefaultMoveRateAttributeCallback callback) { + public void readDefaultMoveRateAttribute( + DefaultMoveRateAttributeCallback callback + ) { readDefaultMoveRateAttribute(chipClusterPtr, callback); } - public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value) { writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, null); } - public void writeDefaultMoveRateAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeDefaultMoveRateAttribute( - DefaultMoveRateAttributeCallback callback, int minInterval, int maxInterval) { + DefaultMoveRateAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeDefaultMoveRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpCurrentLevelAttribute(StartUpCurrentLevelAttributeCallback callback) { + public void readStartUpCurrentLevelAttribute( + StartUpCurrentLevelAttributeCallback callback + ) { readStartUpCurrentLevelAttribute(chipClusterPtr, callback); } - public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpCurrentLevelAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeStartUpCurrentLevelAttribute( - StartUpCurrentLevelAttributeCallback callback, int minInterval, int maxInterval) { + StartUpCurrentLevelAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeStartUpCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRemainingTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRemainingTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOptionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOptionsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOptionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOnOffTransitionTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOnOffTransitionTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOnOffTransitionTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOnLevelAttribute( - long chipClusterPtr, OnLevelAttributeCallback callback); - - private native void writeOnLevelAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOnLevelAttribute( - long chipClusterPtr, OnLevelAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOnTransitionTimeAttribute( - long chipClusterPtr, OnTransitionTimeAttributeCallback callback); - - private native void writeOnTransitionTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOnTransitionTimeAttribute( - long chipClusterPtr, - OnTransitionTimeAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOffTransitionTimeAttribute( - long chipClusterPtr, OffTransitionTimeAttributeCallback callback); - - private native void writeOffTransitionTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOffTransitionTimeAttribute( - long chipClusterPtr, - OffTransitionTimeAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readDefaultMoveRateAttribute( - long chipClusterPtr, DefaultMoveRateAttributeCallback callback); - - private native void writeDefaultMoveRateAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeDefaultMoveRateAttribute( - long chipClusterPtr, - DefaultMoveRateAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readStartUpCurrentLevelAttribute( - long chipClusterPtr, StartUpCurrentLevelAttributeCallback callback); - - private native void writeStartUpCurrentLevelAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeStartUpCurrentLevelAttribute( - long chipClusterPtr, - StartUpCurrentLevelAttributeCallback 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); - } + private native void readCurrentLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOnOffTransitionTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOnOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnOffTransitionTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOnLevelAttribute(long chipClusterPtr, + OnLevelAttributeCallback callback + ); + + private native void writeOnLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnLevelAttribute(long chipClusterPtr, + OnLevelAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOnTransitionTimeAttribute(long chipClusterPtr, + OnTransitionTimeAttributeCallback callback + ); + + private native void writeOnTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnTransitionTimeAttribute(long chipClusterPtr, + OnTransitionTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOffTransitionTimeAttribute(long chipClusterPtr, + OffTransitionTimeAttributeCallback callback + ); + + private native void writeOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOffTransitionTimeAttribute(long chipClusterPtr, + OffTransitionTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readDefaultMoveRateAttribute(long chipClusterPtr, + DefaultMoveRateAttributeCallback callback + ); + + private native void writeDefaultMoveRateAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeDefaultMoveRateAttribute(long chipClusterPtr, + DefaultMoveRateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readStartUpCurrentLevelAttribute(long chipClusterPtr, + StartUpCurrentLevelAttributeCallback callback + ); + + private native void writeStartUpCurrentLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpCurrentLevelAttribute(long chipClusterPtr, + StartUpCurrentLevelAttributeCallback 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 LocalizationConfigurationCluster extends BaseChipCluster { public static final long CLUSTER_ID = 43L; @@ -8081,79 +7283,77 @@ public LocalizationConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SupportedLocalesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface SupportedLocalesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readActiveLocaleAttribute(CharStringAttributeCallback callback) { + public void readActiveLocaleAttribute( + CharStringAttributeCallback callback + ) { readActiveLocaleAttribute(chipClusterPtr, callback); } - public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value) { writeActiveLocaleAttribute(chipClusterPtr, callback, value, null); } - public void writeActiveLocaleAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeActiveLocaleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeActiveLocaleAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActiveLocaleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedLocalesAttribute(SupportedLocalesAttributeCallback callback) { + public void readSupportedLocalesAttribute( + SupportedLocalesAttributeCallback callback + ) { readSupportedLocalesAttribute(chipClusterPtr, callback); } - public void subscribeSupportedLocalesAttribute( - SupportedLocalesAttributeCallback callback, int minInterval, int maxInterval) { + SupportedLocalesAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeSupportedLocalesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readActiveLocaleAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeActiveLocaleAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeActiveLocaleAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSupportedLocalesAttribute( - long chipClusterPtr, SupportedLocalesAttributeCallback callback); - - private native void subscribeSupportedLocalesAttribute( - long chipClusterPtr, - SupportedLocalesAttributeCallback 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); + private native void readActiveLocaleAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeActiveLocaleAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeActiveLocaleAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedLocalesAttribute(long chipClusterPtr, + SupportedLocalesAttributeCallback callback + ); + private native void subscribeSupportedLocalesAttribute(long chipClusterPtr, + SupportedLocalesAttributeCallback 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 LowPowerCluster extends BaseChipCluster { @@ -8166,60 +7366,63 @@ public LowPowerCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void sleep(DefaultClusterCallback callback) { + public void sleep(DefaultClusterCallback callback + ) { sleep(chipClusterPtr, callback, null); } - public void sleep(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void sleep(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { sleep(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void sleep(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); - private native void sleep( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 MediaInputCluster extends BaseChipCluster { @@ -8232,146 +7435,148 @@ public MediaInputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void hideInputStatusRequest(DefaultClusterCallback callback) { + public void hideInputStatusRequest(DefaultClusterCallback callback + ) { hideInputStatusRequest(chipClusterPtr, callback, null); } - public void hideInputStatusRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void hideInputStatusRequest(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { hideInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void renameInputRequest(DefaultClusterCallback callback, Integer index, String name) { + public void renameInputRequest(DefaultClusterCallback callback + , Integer index, String name) { renameInputRequest(chipClusterPtr, callback, index, name, null); } - public void renameInputRequest( - DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) { + public void renameInputRequest(DefaultClusterCallback callback + , Integer index, String name + , int timedInvokeTimeoutMs) { renameInputRequest(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); } - public void selectInputRequest(DefaultClusterCallback callback, Integer index) { + public void selectInputRequest(DefaultClusterCallback callback + , Integer index) { selectInputRequest(chipClusterPtr, callback, index, null); } - public void selectInputRequest( - DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) { + public void selectInputRequest(DefaultClusterCallback callback + , Integer index + , int timedInvokeTimeoutMs) { selectInputRequest(chipClusterPtr, callback, index, timedInvokeTimeoutMs); } - public void showInputStatusRequest(DefaultClusterCallback callback) { + public void showInputStatusRequest(DefaultClusterCallback callback + ) { showInputStatusRequest(chipClusterPtr, callback, null); } - public void showInputStatusRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void showInputStatusRequest(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { showInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void hideInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void renameInputRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index, String name + , @Nullable Integer timedInvokeTimeoutMs); + private native void selectInputRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index + , @Nullable Integer timedInvokeTimeoutMs); + private native void showInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface MediaInputListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void hideInputStatusRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void renameInputRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer index, - String name, - @Nullable Integer timedInvokeTimeoutMs); - - private native void selectInputRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer index, - @Nullable Integer timedInvokeTimeoutMs); - - private native void showInputStatusRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface MediaInputListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readMediaInputListAttribute(MediaInputListAttributeCallback callback) { + public void readMediaInputListAttribute( + MediaInputListAttributeCallback callback + ) { readMediaInputListAttribute(chipClusterPtr, callback); } - public void subscribeMediaInputListAttribute( - MediaInputListAttributeCallback callback, int minInterval, int maxInterval) { + MediaInputListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeMediaInputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentMediaInputAttribute(IntegerAttributeCallback callback) { + public void readCurrentMediaInputAttribute( + IntegerAttributeCallback callback + ) { readCurrentMediaInputAttribute(chipClusterPtr, callback); } - public void subscribeCurrentMediaInputAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentMediaInputAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMediaInputListAttribute( - long chipClusterPtr, MediaInputListAttributeCallback callback); - - private native void subscribeMediaInputListAttribute( - long chipClusterPtr, - MediaInputListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentMediaInputAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentMediaInputAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMediaInputListAttribute(long chipClusterPtr, + MediaInputListAttributeCallback callback + ); + private native void subscribeMediaInputListAttribute(long chipClusterPtr, + MediaInputListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentMediaInputAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentMediaInputAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class MediaPlaybackCluster extends BaseChipCluster { @@ -8384,304 +7589,323 @@ public MediaPlaybackCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void fastForwardRequest(PlaybackResponseCallback callback) { + public void fastForwardRequest(PlaybackResponseCallback callback + ) { fastForwardRequest(chipClusterPtr, callback, null); } - public void fastForwardRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void fastForwardRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { fastForwardRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void nextRequest(PlaybackResponseCallback callback) { + public void nextRequest(PlaybackResponseCallback callback + ) { nextRequest(chipClusterPtr, callback, null); } - public void nextRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void nextRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { nextRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void pauseRequest(PlaybackResponseCallback callback) { + public void pauseRequest(PlaybackResponseCallback callback + ) { pauseRequest(chipClusterPtr, callback, null); } - public void pauseRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void pauseRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { pauseRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void playRequest(PlaybackResponseCallback callback) { + public void playRequest(PlaybackResponseCallback callback + ) { playRequest(chipClusterPtr, callback, null); } - public void playRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void playRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { playRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void previousRequest(PlaybackResponseCallback callback) { + public void previousRequest(PlaybackResponseCallback callback + ) { previousRequest(chipClusterPtr, callback, null); } - public void previousRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void previousRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { previousRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void rewindRequest(PlaybackResponseCallback callback) { + public void rewindRequest(PlaybackResponseCallback callback + ) { rewindRequest(chipClusterPtr, callback, null); } - public void rewindRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void rewindRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { rewindRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void seekRequest(PlaybackResponseCallback callback, Long position) { + public void seekRequest(PlaybackResponseCallback callback + , Long position) { seekRequest(chipClusterPtr, callback, position, null); } - public void seekRequest( - PlaybackResponseCallback callback, Long position, int timedInvokeTimeoutMs) { + public void seekRequest(PlaybackResponseCallback callback + , Long position + , int timedInvokeTimeoutMs) { seekRequest(chipClusterPtr, callback, position, timedInvokeTimeoutMs); } - public void skipBackwardRequest( - PlaybackResponseCallback callback, Long deltaPositionMilliseconds) { + public void skipBackwardRequest(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds) { skipBackwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, null); } - public void skipBackwardRequest( - PlaybackResponseCallback callback, - Long deltaPositionMilliseconds, - int timedInvokeTimeoutMs) { - skipBackwardRequest( - chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); + public void skipBackwardRequest(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds + , int timedInvokeTimeoutMs) { + skipBackwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); } - public void skipForwardRequest( - PlaybackResponseCallback callback, Long deltaPositionMilliseconds) { + public void skipForwardRequest(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds) { skipForwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, null); } - public void skipForwardRequest( - PlaybackResponseCallback callback, - Long deltaPositionMilliseconds, - int timedInvokeTimeoutMs) { + public void skipForwardRequest(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds + , int timedInvokeTimeoutMs) { skipForwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); } - public void startOverRequest(PlaybackResponseCallback callback) { + public void startOverRequest(PlaybackResponseCallback callback + ) { startOverRequest(chipClusterPtr, callback, null); } - public void startOverRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void startOverRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { startOverRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void stopRequest(PlaybackResponseCallback callback) { + public void stopRequest(PlaybackResponseCallback callback + ) { stopRequest(chipClusterPtr, callback, null); } - public void stopRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void stopRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { stopRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - - private native void fastForwardRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void nextRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void pauseRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void playRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void previousRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void rewindRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void seekRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - Long position, - @Nullable Integer timedInvokeTimeoutMs); - - private native void skipBackwardRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - Long deltaPositionMilliseconds, - @Nullable Integer timedInvokeTimeoutMs); - - private native void skipForwardRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - Long deltaPositionMilliseconds, - @Nullable Integer timedInvokeTimeoutMs); - - private native void startOverRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - + private native void fastForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void nextRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void pauseRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void playRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void previousRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void rewindRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void seekRequest(long chipClusterPtr, PlaybackResponseCallback Callback + , Long position + , @Nullable Integer timedInvokeTimeoutMs); + private native void skipBackwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback + , Long deltaPositionMilliseconds + , @Nullable Integer timedInvokeTimeoutMs); + private native void skipForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback + , Long deltaPositionMilliseconds + , @Nullable Integer timedInvokeTimeoutMs); + private native void startOverRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); public interface PlaybackResponseCallback { void onSuccess(Integer status); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readPlaybackStateAttribute(IntegerAttributeCallback callback) { + public void readPlaybackStateAttribute( + IntegerAttributeCallback callback + ) { readPlaybackStateAttribute(chipClusterPtr, callback); } - public void subscribePlaybackStateAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePlaybackStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartTimeAttribute(LongAttributeCallback callback) { + public void readStartTimeAttribute( + LongAttributeCallback callback + ) { readStartTimeAttribute(chipClusterPtr, callback); } - public void subscribeStartTimeAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStartTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDurationAttribute(LongAttributeCallback callback) { + public void readDurationAttribute( + LongAttributeCallback callback + ) { readDurationAttribute(chipClusterPtr, callback); } - public void subscribeDurationAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPlaybackSpeedAttribute(FloatAttributeCallback callback) { + public void readPlaybackSpeedAttribute( + FloatAttributeCallback callback + ) { readPlaybackSpeedAttribute(chipClusterPtr, callback); } - public void subscribePlaybackSpeedAttribute( - FloatAttributeCallback callback, int minInterval, int maxInterval) { + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePlaybackSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSeekRangeEndAttribute(LongAttributeCallback callback) { + public void readSeekRangeEndAttribute( + LongAttributeCallback callback + ) { readSeekRangeEndAttribute(chipClusterPtr, callback); } - public void subscribeSeekRangeEndAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSeekRangeEndAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSeekRangeStartAttribute(LongAttributeCallback callback) { + public void readSeekRangeStartAttribute( + LongAttributeCallback callback + ) { readSeekRangeStartAttribute(chipClusterPtr, callback); } - public void subscribeSeekRangeStartAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSeekRangeStartAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readPlaybackStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePlaybackStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStartTimeAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeStartTimeAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDurationAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeDurationAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPlaybackSpeedAttribute( - long chipClusterPtr, FloatAttributeCallback callback); - - private native void subscribePlaybackSpeedAttribute( - long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSeekRangeEndAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeSeekRangeEndAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSeekRangeStartAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeSeekRangeStartAttribute( - long chipClusterPtr, LongAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readPlaybackStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePlaybackStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeStartTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDurationAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeDurationAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPlaybackSpeedAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribePlaybackSpeedAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSeekRangeEndAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSeekRangeEndAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSeekRangeStartAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSeekRangeStartAttribute(long chipClusterPtr, + LongAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ModeSelectCluster extends BaseChipCluster { @@ -8694,164 +7918,172 @@ public ModeSelectCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void changeToMode(DefaultClusterCallback callback, Integer newMode) { + public void changeToMode(DefaultClusterCallback callback + , Integer newMode) { changeToMode(chipClusterPtr, callback, newMode, null); } - public void changeToMode( - DefaultClusterCallback callback, Integer newMode, int timedInvokeTimeoutMs) { + public void changeToMode(DefaultClusterCallback callback + , Integer newMode + , int timedInvokeTimeoutMs) { changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs); } + private native void changeToMode(long chipClusterPtr, DefaultClusterCallback Callback + , Integer newMode + , @Nullable Integer timedInvokeTimeoutMs); - private native void changeToMode( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer newMode, - @Nullable Integer timedInvokeTimeoutMs); - - public interface SupportedModesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface SupportedModesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readCurrentModeAttribute(IntegerAttributeCallback callback) { + public void readCurrentModeAttribute( + IntegerAttributeCallback callback + ) { readCurrentModeAttribute(chipClusterPtr, callback); } - public void subscribeCurrentModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedModesAttribute(SupportedModesAttributeCallback callback) { + public void readSupportedModesAttribute( + SupportedModesAttributeCallback callback + ) { readSupportedModesAttribute(chipClusterPtr, callback); } - public void subscribeSupportedModesAttribute( - SupportedModesAttributeCallback callback, int minInterval, int maxInterval) { + SupportedModesAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnModeAttribute(IntegerAttributeCallback callback) { + public void readOnModeAttribute( + IntegerAttributeCallback callback + ) { readOnModeAttribute(chipClusterPtr, callback); } - public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) { writeOnModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOnModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpModeAttribute(IntegerAttributeCallback callback) { + public void readStartUpModeAttribute( + IntegerAttributeCallback callback + ) { readStartUpModeAttribute(chipClusterPtr, callback); } - public void subscribeStartUpModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDescriptionAttribute(CharStringAttributeCallback callback) { + public void readDescriptionAttribute( + CharStringAttributeCallback callback + ) { readDescriptionAttribute(chipClusterPtr, callback); } - public void subscribeDescriptionAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSupportedModesAttribute( - long chipClusterPtr, SupportedModesAttributeCallback callback); - - private native void subscribeSupportedModesAttribute( - long chipClusterPtr, - SupportedModesAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOnModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOnModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOnModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStartUpModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeStartUpModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDescriptionAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeDescriptionAttribute( - long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + ); + private native void subscribeSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOnModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStartUpModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class NetworkCommissioningCluster extends BaseChipCluster { @@ -8864,334 +8096,312 @@ public NetworkCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addOrUpdateThreadNetwork( - NetworkConfigResponseCallback callback, byte[] operationalDataset, Long breadcrumb) { + public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback + , byte[] operationalDataset, Long breadcrumb) { addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, null); } - public void addOrUpdateThreadNetwork( - NetworkConfigResponseCallback callback, - byte[] operationalDataset, - Long breadcrumb, - int timedInvokeTimeoutMs) { - addOrUpdateThreadNetwork( - chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs); + public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback + , byte[] operationalDataset, Long breadcrumb + , int timedInvokeTimeoutMs) { + addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs); } - public void addOrUpdateWiFiNetwork( - NetworkConfigResponseCallback callback, byte[] ssid, byte[] credentials, Long breadcrumb) { + public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback + , byte[] ssid, byte[] credentials, Long breadcrumb) { addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, null); } - public void addOrUpdateWiFiNetwork( - NetworkConfigResponseCallback callback, - byte[] ssid, - byte[] credentials, - Long breadcrumb, - int timedInvokeTimeoutMs) { - addOrUpdateWiFiNetwork( - chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs); + public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback + , byte[] ssid, byte[] credentials, Long breadcrumb + , int timedInvokeTimeoutMs) { + addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs); } - public void connectNetwork( - ConnectNetworkResponseCallback callback, byte[] networkID, Long breadcrumb) { + public void connectNetwork(ConnectNetworkResponseCallback callback + , byte[] networkID, Long breadcrumb) { connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); } - public void connectNetwork( - ConnectNetworkResponseCallback callback, - byte[] networkID, - Long breadcrumb, - int timedInvokeTimeoutMs) { + public void connectNetwork(ConnectNetworkResponseCallback callback + , byte[] networkID, Long breadcrumb + , int timedInvokeTimeoutMs) { connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); } - public void removeNetwork( - NetworkConfigResponseCallback callback, byte[] networkID, Long breadcrumb) { + public void removeNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Long breadcrumb) { removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); } - public void removeNetwork( - NetworkConfigResponseCallback callback, - byte[] networkID, - Long breadcrumb, - int timedInvokeTimeoutMs) { + public void removeNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Long breadcrumb + , int timedInvokeTimeoutMs) { removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); } - public void reorderNetwork( - NetworkConfigResponseCallback callback, - byte[] networkID, - Integer networkIndex, - Long breadcrumb) { + public void reorderNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Integer networkIndex, Long breadcrumb) { reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, null); } - public void reorderNetwork( - NetworkConfigResponseCallback callback, - byte[] networkID, - Integer networkIndex, - Long breadcrumb, - int timedInvokeTimeoutMs) { - reorderNetwork( - chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs); + public void reorderNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Integer networkIndex, Long breadcrumb + , int timedInvokeTimeoutMs) { + reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs); } - public void scanNetworks(ScanNetworksResponseCallback callback, byte[] ssid, Long breadcrumb) { + public void scanNetworks(ScanNetworksResponseCallback callback + , byte[] ssid, Long breadcrumb) { scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, null); } - public void scanNetworks( - ScanNetworksResponseCallback callback, - byte[] ssid, - Long breadcrumb, - int timedInvokeTimeoutMs) { + public void scanNetworks(ScanNetworksResponseCallback callback + , byte[] ssid, Long breadcrumb + , int timedInvokeTimeoutMs) { scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, timedInvokeTimeoutMs); } - - private native void addOrUpdateThreadNetwork( - long chipClusterPtr, - NetworkConfigResponseCallback Callback, - byte[] operationalDataset, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - - private native void addOrUpdateWiFiNetwork( - long chipClusterPtr, - NetworkConfigResponseCallback Callback, - byte[] ssid, - byte[] credentials, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - - private native void connectNetwork( - long chipClusterPtr, - ConnectNetworkResponseCallback Callback, - byte[] networkID, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeNetwork( - long chipClusterPtr, - NetworkConfigResponseCallback Callback, - byte[] networkID, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - - private native void reorderNetwork( - long chipClusterPtr, - NetworkConfigResponseCallback Callback, - byte[] networkID, - Integer networkIndex, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - - private native void scanNetworks( - long chipClusterPtr, - ScanNetworksResponseCallback Callback, - byte[] ssid, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - + private native void addOrUpdateThreadNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] operationalDataset, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void addOrUpdateWiFiNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] ssid, byte[] credentials, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void connectNetwork(long chipClusterPtr, ConnectNetworkResponseCallback Callback + , byte[] networkID, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] networkID, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void reorderNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] networkID, Integer networkIndex, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void scanNetworks(long chipClusterPtr, ScanNetworksResponseCallback Callback + , byte[] ssid, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); public interface ConnectNetworkResponseCallback { void onSuccess(Integer networkingStatus, String debugText, Long errorValue); - + void onError(Exception error); } public interface NetworkConfigResponseCallback { void onSuccess(Integer networkingStatus, String debugText); - + void onError(Exception error); } public interface ScanNetworksResponseCallback { - void onSuccess( - Integer networkingStatus, - String debugText, - Optional> - wiFiScanResults, - Optional> - threadScanResults); - + void onSuccess(Integer networkingStatus, String debugText, Optional> wiFiScanResults, Optional> threadScanResults); + void onError(Exception error); } - public interface NetworksAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface NetworksAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMaxNetworksAttribute(IntegerAttributeCallback callback) { + public void readMaxNetworksAttribute( + IntegerAttributeCallback callback + ) { readMaxNetworksAttribute(chipClusterPtr, callback); } - public void subscribeMaxNetworksAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNetworksAttribute(NetworksAttributeCallback callback) { + public void readNetworksAttribute( + NetworksAttributeCallback callback + ) { readNetworksAttribute(chipClusterPtr, callback); } - public void subscribeNetworksAttribute( - NetworksAttributeCallback callback, int minInterval, int maxInterval) { + NetworksAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readScanMaxTimeSecondsAttribute(IntegerAttributeCallback callback) { + public void readScanMaxTimeSecondsAttribute( + IntegerAttributeCallback callback + ) { readScanMaxTimeSecondsAttribute(chipClusterPtr, callback); } - public void subscribeScanMaxTimeSecondsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeScanMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readConnectMaxTimeSecondsAttribute(IntegerAttributeCallback callback) { + public void readConnectMaxTimeSecondsAttribute( + IntegerAttributeCallback callback + ) { readConnectMaxTimeSecondsAttribute(chipClusterPtr, callback); } - public void subscribeConnectMaxTimeSecondsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeConnectMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInterfaceEnabledAttribute(BooleanAttributeCallback callback) { + public void readInterfaceEnabledAttribute( + BooleanAttributeCallback callback + ) { readInterfaceEnabledAttribute(chipClusterPtr, callback); } - public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value) { writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, null); } - public void writeInterfaceEnabledAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInterfaceEnabledAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInterfaceEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastNetworkingStatusAttribute(IntegerAttributeCallback callback) { + public void readLastNetworkingStatusAttribute( + IntegerAttributeCallback callback + ) { readLastNetworkingStatusAttribute(chipClusterPtr, callback); } - public void subscribeLastNetworkingStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLastNetworkingStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastNetworkIDAttribute(OctetStringAttributeCallback callback) { + public void readLastNetworkIDAttribute( + OctetStringAttributeCallback callback + ) { readLastNetworkIDAttribute(chipClusterPtr, callback); } - public void subscribeLastNetworkIDAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLastNetworkIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastConnectErrorValueAttribute(LongAttributeCallback callback) { + public void readLastConnectErrorValueAttribute( + LongAttributeCallback callback + ) { readLastConnectErrorValueAttribute(chipClusterPtr, callback); } - public void subscribeLastConnectErrorValueAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLastConnectErrorValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMaxNetworksAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxNetworksAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNetworksAttribute( - long chipClusterPtr, NetworksAttributeCallback callback); - - private native void subscribeNetworksAttribute( - long chipClusterPtr, NetworksAttributeCallback callback, int minInterval, int maxInterval); - - private native void readScanMaxTimeSecondsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeScanMaxTimeSecondsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readConnectMaxTimeSecondsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeConnectMaxTimeSecondsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInterfaceEnabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeInterfaceEnabledAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInterfaceEnabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLastNetworkingStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLastNetworkingStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLastNetworkIDAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void subscribeLastNetworkIDAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readLastConnectErrorValueAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeLastConnectErrorValueAttribute( - long chipClusterPtr, LongAttributeCallback 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); + private native void readMaxNetworksAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxNetworksAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNetworksAttribute(long chipClusterPtr, + NetworksAttributeCallback callback + ); + private native void subscribeNetworksAttribute(long chipClusterPtr, + NetworksAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readScanMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeScanMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readConnectMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeConnectMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInterfaceEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeInterfaceEnabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInterfaceEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLastNetworkingStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLastNetworkingStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLastNetworkIDAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + private native void subscribeLastNetworkIDAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLastConnectErrorValueAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeLastConnectErrorValueAttribute(long chipClusterPtr, + LongAttributeCallback 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 OtaSoftwareUpdateProviderCluster extends BaseChipCluster { @@ -9204,169 +8414,103 @@ public OtaSoftwareUpdateProviderCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void applyUpdateRequest( - ApplyUpdateResponseCallback callback, byte[] updateToken, Long newVersion) { + public void applyUpdateRequest(ApplyUpdateResponseCallback callback + , byte[] updateToken, Long newVersion) { applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, null); } - public void applyUpdateRequest( - ApplyUpdateResponseCallback callback, - byte[] updateToken, - Long newVersion, - int timedInvokeTimeoutMs) { + public void applyUpdateRequest(ApplyUpdateResponseCallback callback + , byte[] updateToken, Long newVersion + , int timedInvokeTimeoutMs) { applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, timedInvokeTimeoutMs); } - public void notifyUpdateApplied( - DefaultClusterCallback callback, byte[] updateToken, Long softwareVersion) { + public void notifyUpdateApplied(DefaultClusterCallback callback + , byte[] updateToken, Long softwareVersion) { notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, null); } - public void notifyUpdateApplied( - DefaultClusterCallback callback, - byte[] updateToken, - Long softwareVersion, - int timedInvokeTimeoutMs) { - notifyUpdateApplied( - chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs); - } - - public void queryImage( - QueryImageResponseCallback callback, - Integer vendorId, - Integer productId, - Long softwareVersion, - ArrayList protocolsSupported, - Optional hardwareVersion, - Optional location, - Optional requestorCanConsent, - Optional metadataForProvider) { - queryImage( - chipClusterPtr, - callback, - vendorId, - productId, - softwareVersion, - protocolsSupported, - hardwareVersion, - location, - requestorCanConsent, - metadataForProvider, - null); - } - - public void queryImage( - QueryImageResponseCallback callback, - Integer vendorId, - Integer productId, - Long softwareVersion, - ArrayList protocolsSupported, - Optional hardwareVersion, - Optional location, - Optional requestorCanConsent, - Optional metadataForProvider, - int timedInvokeTimeoutMs) { - queryImage( - chipClusterPtr, - callback, - vendorId, - productId, - softwareVersion, - protocolsSupported, - hardwareVersion, - location, - requestorCanConsent, - metadataForProvider, - timedInvokeTimeoutMs); - } - - private native void applyUpdateRequest( - long chipClusterPtr, - ApplyUpdateResponseCallback Callback, - byte[] updateToken, - Long newVersion, - @Nullable Integer timedInvokeTimeoutMs); - - private native void notifyUpdateApplied( - long chipClusterPtr, - DefaultClusterCallback Callback, - byte[] updateToken, - Long softwareVersion, - @Nullable Integer timedInvokeTimeoutMs); - - private native void queryImage( - long chipClusterPtr, - QueryImageResponseCallback Callback, - Integer vendorId, - Integer productId, - Long softwareVersion, - ArrayList protocolsSupported, - Optional hardwareVersion, - Optional location, - Optional requestorCanConsent, - Optional metadataForProvider, - @Nullable Integer timedInvokeTimeoutMs); + public void notifyUpdateApplied(DefaultClusterCallback callback + , byte[] updateToken, Long softwareVersion + , int timedInvokeTimeoutMs) { + notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs); + } + + public void queryImage(QueryImageResponseCallback callback + , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider) { + queryImage(chipClusterPtr, callback, vendorId, productId, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, null); + } + public void queryImage(QueryImageResponseCallback callback + , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider + , int timedInvokeTimeoutMs) { + queryImage(chipClusterPtr, callback, vendorId, productId, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, timedInvokeTimeoutMs); + } + private native void applyUpdateRequest(long chipClusterPtr, ApplyUpdateResponseCallback Callback + , byte[] updateToken, Long newVersion + , @Nullable Integer timedInvokeTimeoutMs); + private native void notifyUpdateApplied(long chipClusterPtr, DefaultClusterCallback Callback + , byte[] updateToken, Long softwareVersion + , @Nullable Integer timedInvokeTimeoutMs); + private native void queryImage(long chipClusterPtr, QueryImageResponseCallback Callback + , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider + , @Nullable Integer timedInvokeTimeoutMs); public interface ApplyUpdateResponseCallback { void onSuccess(Integer action, Long delayedActionTime); - + void onError(Exception error); } public interface QueryImageResponseCallback { - void onSuccess( - Integer status, - Optional delayedActionTime, - Optional imageURI, - Optional softwareVersion, - Optional softwareVersionString, - Optional updateToken, - Optional userConsentNeeded, - Optional metadataForRequestor); - + void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor); + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 OtaSoftwareUpdateRequestorCluster extends BaseChipCluster { @@ -9379,194 +8523,158 @@ public OtaSoftwareUpdateRequestorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void announceOtaProvider( - DefaultClusterCallback callback, - Long providerNodeId, - Integer vendorId, - Integer announcementReason, - Optional metadataForNode, - Integer endpoint) { - announceOtaProvider( - chipClusterPtr, - callback, - providerNodeId, - vendorId, - announcementReason, - metadataForNode, - endpoint, - null); - } - - public void announceOtaProvider( - DefaultClusterCallback callback, - Long providerNodeId, - Integer vendorId, - Integer announcementReason, - Optional metadataForNode, - Integer endpoint, - int timedInvokeTimeoutMs) { - announceOtaProvider( - chipClusterPtr, - callback, - providerNodeId, - vendorId, - announcementReason, - metadataForNode, - endpoint, - timedInvokeTimeoutMs); - } - - private native void announceOtaProvider( - long chipClusterPtr, - DefaultClusterCallback Callback, - Long providerNodeId, - Integer vendorId, - Integer announcementReason, - Optional metadataForNode, - Integer endpoint, - @Nullable Integer timedInvokeTimeoutMs); - - public interface DefaultOtaProvidersAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void announceOtaProvider(DefaultClusterCallback callback + , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint) { + announceOtaProvider(chipClusterPtr, callback, providerNodeId, vendorId, announcementReason, metadataForNode, endpoint, null); } - public interface UpdateStateProgressAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void announceOtaProvider(DefaultClusterCallback callback + , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint + , int timedInvokeTimeoutMs) { + announceOtaProvider(chipClusterPtr, callback, providerNodeId, vendorId, announcementReason, metadataForNode, endpoint, timedInvokeTimeoutMs); } + private native void announceOtaProvider(long chipClusterPtr, DefaultClusterCallback Callback + , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint + , @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface DefaultOtaProvidersAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface UpdateStateProgressAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readDefaultOtaProvidersAttribute(DefaultOtaProvidersAttributeCallback callback) { + public void readDefaultOtaProvidersAttribute( + DefaultOtaProvidersAttributeCallback callback + ) { readDefaultOtaProvidersAttribute(chipClusterPtr, callback); } - - public void writeDefaultOtaProvidersAttribute( - DefaultClusterCallback callback, - ArrayList value) { + public void writeDefaultOtaProvidersAttribute(DefaultClusterCallback callback, ArrayList value) { writeDefaultOtaProvidersAttribute(chipClusterPtr, callback, value, null); } - public void writeDefaultOtaProvidersAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { + public void writeDefaultOtaProvidersAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeDefaultOtaProvidersAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeDefaultOtaProvidersAttribute( - DefaultOtaProvidersAttributeCallback callback, int minInterval, int maxInterval) { + DefaultOtaProvidersAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeDefaultOtaProvidersAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdatePossibleAttribute(BooleanAttributeCallback callback) { + public void readUpdatePossibleAttribute( + BooleanAttributeCallback callback + ) { readUpdatePossibleAttribute(chipClusterPtr, callback); } - public void subscribeUpdatePossibleAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeUpdatePossibleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdateStateAttribute(IntegerAttributeCallback callback) { + public void readUpdateStateAttribute( + IntegerAttributeCallback callback + ) { readUpdateStateAttribute(chipClusterPtr, callback); } - public void subscribeUpdateStateAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeUpdateStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdateStateProgressAttribute(UpdateStateProgressAttributeCallback callback) { + public void readUpdateStateProgressAttribute( + UpdateStateProgressAttributeCallback callback + ) { readUpdateStateProgressAttribute(chipClusterPtr, callback); } - public void subscribeUpdateStateProgressAttribute( - UpdateStateProgressAttributeCallback callback, int minInterval, int maxInterval) { + UpdateStateProgressAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeUpdateStateProgressAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readDefaultOtaProvidersAttribute( - long chipClusterPtr, DefaultOtaProvidersAttributeCallback callback); - - private native void writeDefaultOtaProvidersAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeDefaultOtaProvidersAttribute( - long chipClusterPtr, - DefaultOtaProvidersAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readUpdatePossibleAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeUpdatePossibleAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readUpdateStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeUpdateStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readUpdateStateProgressAttribute( - long chipClusterPtr, UpdateStateProgressAttributeCallback callback); - - private native void subscribeUpdateStateProgressAttribute( - long chipClusterPtr, - UpdateStateProgressAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readDefaultOtaProvidersAttribute(long chipClusterPtr, + DefaultOtaProvidersAttributeCallback callback + ); + + private native void writeDefaultOtaProvidersAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeDefaultOtaProvidersAttribute(long chipClusterPtr, + DefaultOtaProvidersAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readUpdatePossibleAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeUpdatePossibleAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUpdateStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeUpdateStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUpdateStateProgressAttribute(long chipClusterPtr, + UpdateStateProgressAttributeCallback callback + ); + private native void subscribeUpdateStateProgressAttribute(long chipClusterPtr, + UpdateStateProgressAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class OccupancySensingCluster extends BaseChipCluster { @@ -9579,92 +8687,106 @@ public OccupancySensingCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readOccupancyAttribute(IntegerAttributeCallback callback) { + public void readOccupancyAttribute( + IntegerAttributeCallback callback + ) { readOccupancyAttribute(chipClusterPtr, callback); } - public void subscribeOccupancyAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOccupancyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupancySensorTypeAttribute(IntegerAttributeCallback callback) { + public void readOccupancySensorTypeAttribute( + IntegerAttributeCallback callback + ) { readOccupancySensorTypeAttribute(chipClusterPtr, callback); } - public void subscribeOccupancySensorTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOccupancySensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupancySensorTypeBitmapAttribute(IntegerAttributeCallback callback) { + public void readOccupancySensorTypeBitmapAttribute( + IntegerAttributeCallback callback + ) { readOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback); } - public void subscribeOccupancySensorTypeBitmapAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeOccupancySensorTypeBitmapAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOccupancyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeOccupancyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOccupancySensorTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeOccupancySensorTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOccupancySensorTypeBitmapAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeOccupancySensorTypeBitmapAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readOccupancyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOccupancyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOccupancySensorTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeBitmapAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOccupancySensorTypeBitmapAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class OnOffCluster extends BaseChipCluster { @@ -9677,281 +8799,274 @@ public OnOffCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void off(DefaultClusterCallback callback) { + public void off(DefaultClusterCallback callback + ) { off(chipClusterPtr, callback, null); } - public void off(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void off(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { off(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void offWithEffect( - DefaultClusterCallback callback, Integer effectId, Integer effectVariant) { + public void offWithEffect(DefaultClusterCallback callback + , Integer effectId, Integer effectVariant) { offWithEffect(chipClusterPtr, callback, effectId, effectVariant, null); } - public void offWithEffect( - DefaultClusterCallback callback, - Integer effectId, - Integer effectVariant, - int timedInvokeTimeoutMs) { + public void offWithEffect(DefaultClusterCallback callback + , Integer effectId, Integer effectVariant + , int timedInvokeTimeoutMs) { offWithEffect(chipClusterPtr, callback, effectId, effectVariant, timedInvokeTimeoutMs); } - public void on(DefaultClusterCallback callback) { + public void on(DefaultClusterCallback callback + ) { on(chipClusterPtr, callback, null); } - public void on(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void on(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { on(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void onWithRecallGlobalScene(DefaultClusterCallback callback) { + public void onWithRecallGlobalScene(DefaultClusterCallback callback + ) { onWithRecallGlobalScene(chipClusterPtr, callback, null); } - public void onWithRecallGlobalScene(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void onWithRecallGlobalScene(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { onWithRecallGlobalScene(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void onWithTimedOff( - DefaultClusterCallback callback, - Integer onOffControl, - Integer onTime, - Integer offWaitTime) { + public void onWithTimedOff(DefaultClusterCallback callback + , Integer onOffControl, Integer onTime, Integer offWaitTime) { onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, null); } - public void onWithTimedOff( - DefaultClusterCallback callback, - Integer onOffControl, - Integer onTime, - Integer offWaitTime, - int timedInvokeTimeoutMs) { - onWithTimedOff( - chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs); + public void onWithTimedOff(DefaultClusterCallback callback + , Integer onOffControl, Integer onTime, Integer offWaitTime + , int timedInvokeTimeoutMs) { + onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs); } - public void toggle(DefaultClusterCallback callback) { + public void toggle(DefaultClusterCallback callback + ) { toggle(chipClusterPtr, callback, null); } - public void toggle(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void toggle(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { toggle(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void off(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void offWithEffect(long chipClusterPtr, DefaultClusterCallback Callback + , Integer effectId, Integer effectVariant + , @Nullable Integer timedInvokeTimeoutMs); + private native void on(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void onWithRecallGlobalScene(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void onWithTimedOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer onOffControl, Integer onTime, Integer offWaitTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void toggle(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void off( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void offWithEffect( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer effectId, - Integer effectVariant, - @Nullable Integer timedInvokeTimeoutMs); - - private native void on( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void onWithRecallGlobalScene( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void onWithTimedOff( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer onOffControl, - Integer onTime, - Integer offWaitTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void toggle( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readOnOffAttribute(BooleanAttributeCallback callback) { + public void readOnOffAttribute( + BooleanAttributeCallback callback + ) { readOnOffAttribute(chipClusterPtr, callback); } - public void subscribeOnOffAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGlobalSceneControlAttribute(BooleanAttributeCallback callback) { + public void readGlobalSceneControlAttribute( + BooleanAttributeCallback callback + ) { readGlobalSceneControlAttribute(chipClusterPtr, callback); } - public void subscribeGlobalSceneControlAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeGlobalSceneControlAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnTimeAttribute(IntegerAttributeCallback callback) { + public void readOnTimeAttribute( + IntegerAttributeCallback callback + ) { readOnTimeAttribute(chipClusterPtr, callback); } - public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOnTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOnTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOffWaitTimeAttribute(IntegerAttributeCallback callback) { + public void readOffWaitTimeAttribute( + IntegerAttributeCallback callback + ) { readOffWaitTimeAttribute(chipClusterPtr, callback); } - public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOffWaitTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOffWaitTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOffWaitTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOffWaitTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOffWaitTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpOnOffAttribute(IntegerAttributeCallback callback) { + public void readStartUpOnOffAttribute( + IntegerAttributeCallback callback + ) { readStartUpOnOffAttribute(chipClusterPtr, callback); } - public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpOnOffAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpOnOffAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeStartUpOnOffAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeStartUpOnOffAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStartUpOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOnOffAttribute(long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeOnOffAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readGlobalSceneControlAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeGlobalSceneControlAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOnTimeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOnTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOnTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOffWaitTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOffWaitTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOffWaitTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStartUpOnOffAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeStartUpOnOffAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeStartUpOnOffAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readOnOffAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeOnOffAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGlobalSceneControlAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeGlobalSceneControlAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOnTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOnTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOffWaitTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOffWaitTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOffWaitTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpOnOffAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeStartUpOnOffAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpOnOffAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 OnOffSwitchConfigurationCluster extends BaseChipCluster { @@ -9964,91 +9079,96 @@ public OnOffSwitchConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readSwitchTypeAttribute(IntegerAttributeCallback callback) { + public void readSwitchTypeAttribute( + IntegerAttributeCallback callback + ) { readSwitchTypeAttribute(chipClusterPtr, callback); } - public void subscribeSwitchTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSwitchTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSwitchActionsAttribute(IntegerAttributeCallback callback) { + public void readSwitchActionsAttribute( + IntegerAttributeCallback callback + ) { readSwitchActionsAttribute(chipClusterPtr, callback); } - public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value) { writeSwitchActionsAttribute(chipClusterPtr, callback, value, null); } - public void writeSwitchActionsAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSwitchActionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeSwitchActionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSwitchActionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSwitchTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSwitchTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSwitchActionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeSwitchActionsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeSwitchActionsAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readSwitchTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSwitchTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSwitchActionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeSwitchActionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSwitchActionsAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class OperationalCredentialsCluster extends BaseChipCluster { @@ -10061,378 +9181,333 @@ public OperationalCredentialsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addNOC( - NOCResponseCallback callback, - byte[] NOCValue, - Optional ICACValue, - byte[] IPKValue, - Long caseAdminNode, - Integer adminVendorId) { - addNOC( - chipClusterPtr, - callback, - NOCValue, - ICACValue, - IPKValue, - caseAdminNode, - adminVendorId, - null); - } - - public void addNOC( - NOCResponseCallback callback, - byte[] NOCValue, - Optional ICACValue, - byte[] IPKValue, - Long caseAdminNode, - Integer adminVendorId, - int timedInvokeTimeoutMs) { - addNOC( - chipClusterPtr, - callback, - NOCValue, - ICACValue, - IPKValue, - caseAdminNode, - adminVendorId, - timedInvokeTimeoutMs); - } - - public void addTrustedRootCertificate(DefaultClusterCallback callback, byte[] rootCertificate) { + public void addNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId) { + addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminNode, adminVendorId, null); + } + + public void addNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId + , int timedInvokeTimeoutMs) { + addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminNode, adminVendorId, timedInvokeTimeoutMs); + } + + public void addTrustedRootCertificate(DefaultClusterCallback callback + , byte[] rootCertificate) { addTrustedRootCertificate(chipClusterPtr, callback, rootCertificate, null); } - public void addTrustedRootCertificate( - DefaultClusterCallback callback, byte[] rootCertificate, int timedInvokeTimeoutMs) { + public void addTrustedRootCertificate(DefaultClusterCallback callback + , byte[] rootCertificate + , int timedInvokeTimeoutMs) { addTrustedRootCertificate(chipClusterPtr, callback, rootCertificate, timedInvokeTimeoutMs); } - public void attestationRequest(AttestationResponseCallback callback, byte[] attestationNonce) { + public void attestationRequest(AttestationResponseCallback callback + , byte[] attestationNonce) { attestationRequest(chipClusterPtr, callback, attestationNonce, null); } - public void attestationRequest( - AttestationResponseCallback callback, byte[] attestationNonce, int timedInvokeTimeoutMs) { + public void attestationRequest(AttestationResponseCallback callback + , byte[] attestationNonce + , int timedInvokeTimeoutMs) { attestationRequest(chipClusterPtr, callback, attestationNonce, timedInvokeTimeoutMs); } - public void certificateChainRequest( - CertificateChainResponseCallback callback, Integer certificateType) { + public void certificateChainRequest(CertificateChainResponseCallback callback + , Integer certificateType) { certificateChainRequest(chipClusterPtr, callback, certificateType, null); } - public void certificateChainRequest( - CertificateChainResponseCallback callback, - Integer certificateType, - int timedInvokeTimeoutMs) { + public void certificateChainRequest(CertificateChainResponseCallback callback + , Integer certificateType + , int timedInvokeTimeoutMs) { certificateChainRequest(chipClusterPtr, callback, certificateType, timedInvokeTimeoutMs); } - public void opCSRRequest(OpCSRResponseCallback callback, byte[] CSRNonce) { + public void opCSRRequest(OpCSRResponseCallback callback + , byte[] CSRNonce) { opCSRRequest(chipClusterPtr, callback, CSRNonce, null); } - public void opCSRRequest( - OpCSRResponseCallback callback, byte[] CSRNonce, int timedInvokeTimeoutMs) { + public void opCSRRequest(OpCSRResponseCallback callback + , byte[] CSRNonce + , int timedInvokeTimeoutMs) { opCSRRequest(chipClusterPtr, callback, CSRNonce, timedInvokeTimeoutMs); } - public void removeFabric(NOCResponseCallback callback, Integer fabricIndex) { + public void removeFabric(NOCResponseCallback callback + , Integer fabricIndex) { removeFabric(chipClusterPtr, callback, fabricIndex, null); } - public void removeFabric( - NOCResponseCallback callback, Integer fabricIndex, int timedInvokeTimeoutMs) { + public void removeFabric(NOCResponseCallback callback + , Integer fabricIndex + , int timedInvokeTimeoutMs) { removeFabric(chipClusterPtr, callback, fabricIndex, timedInvokeTimeoutMs); } - public void removeTrustedRootCertificate( - DefaultClusterCallback callback, byte[] trustedRootIdentifier) { + public void removeTrustedRootCertificate(DefaultClusterCallback callback + , byte[] trustedRootIdentifier) { removeTrustedRootCertificate(chipClusterPtr, callback, trustedRootIdentifier, null); } - public void removeTrustedRootCertificate( - DefaultClusterCallback callback, byte[] trustedRootIdentifier, int timedInvokeTimeoutMs) { - removeTrustedRootCertificate( - chipClusterPtr, callback, trustedRootIdentifier, timedInvokeTimeoutMs); + public void removeTrustedRootCertificate(DefaultClusterCallback callback + , byte[] trustedRootIdentifier + , int timedInvokeTimeoutMs) { + removeTrustedRootCertificate(chipClusterPtr, callback, trustedRootIdentifier, timedInvokeTimeoutMs); } - public void updateFabricLabel(NOCResponseCallback callback, String label) { + public void updateFabricLabel(NOCResponseCallback callback + , String label) { updateFabricLabel(chipClusterPtr, callback, label, null); } - public void updateFabricLabel( - NOCResponseCallback callback, String label, int timedInvokeTimeoutMs) { + public void updateFabricLabel(NOCResponseCallback callback + , String label + , int timedInvokeTimeoutMs) { updateFabricLabel(chipClusterPtr, callback, label, timedInvokeTimeoutMs); } - public void updateNOC( - NOCResponseCallback callback, byte[] NOCValue, Optional ICACValue) { + public void updateNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue) { updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, null); } - public void updateNOC( - NOCResponseCallback callback, - byte[] NOCValue, - Optional ICACValue, - int timedInvokeTimeoutMs) { + public void updateNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue + , int timedInvokeTimeoutMs) { updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, timedInvokeTimeoutMs); } - - private native void addNOC( - long chipClusterPtr, - NOCResponseCallback Callback, - byte[] NOCValue, - Optional ICACValue, - byte[] IPKValue, - Long caseAdminNode, - Integer adminVendorId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void addTrustedRootCertificate( - long chipClusterPtr, - DefaultClusterCallback Callback, - byte[] rootCertificate, - @Nullable Integer timedInvokeTimeoutMs); - - private native void attestationRequest( - long chipClusterPtr, - AttestationResponseCallback Callback, - byte[] attestationNonce, - @Nullable Integer timedInvokeTimeoutMs); - - private native void certificateChainRequest( - long chipClusterPtr, - CertificateChainResponseCallback Callback, - Integer certificateType, - @Nullable Integer timedInvokeTimeoutMs); - - private native void opCSRRequest( - long chipClusterPtr, - OpCSRResponseCallback Callback, - byte[] CSRNonce, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeFabric( - long chipClusterPtr, - NOCResponseCallback Callback, - Integer fabricIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeTrustedRootCertificate( - long chipClusterPtr, - DefaultClusterCallback Callback, - byte[] trustedRootIdentifier, - @Nullable Integer timedInvokeTimeoutMs); - - private native void updateFabricLabel( - long chipClusterPtr, - NOCResponseCallback Callback, - String label, - @Nullable Integer timedInvokeTimeoutMs); - - private native void updateNOC( - long chipClusterPtr, - NOCResponseCallback Callback, - byte[] NOCValue, - Optional ICACValue, - @Nullable Integer timedInvokeTimeoutMs); - + private native void addNOC(long chipClusterPtr, NOCResponseCallback Callback + , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId + , @Nullable Integer timedInvokeTimeoutMs); + private native void addTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback Callback + , byte[] rootCertificate + , @Nullable Integer timedInvokeTimeoutMs); + private native void attestationRequest(long chipClusterPtr, AttestationResponseCallback Callback + , byte[] attestationNonce + , @Nullable Integer timedInvokeTimeoutMs); + private native void certificateChainRequest(long chipClusterPtr, CertificateChainResponseCallback Callback + , Integer certificateType + , @Nullable Integer timedInvokeTimeoutMs); + private native void opCSRRequest(long chipClusterPtr, OpCSRResponseCallback Callback + , byte[] CSRNonce + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeFabric(long chipClusterPtr, NOCResponseCallback Callback + , Integer fabricIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback Callback + , byte[] trustedRootIdentifier + , @Nullable Integer timedInvokeTimeoutMs); + private native void updateFabricLabel(long chipClusterPtr, NOCResponseCallback Callback + , String label + , @Nullable Integer timedInvokeTimeoutMs); + private native void updateNOC(long chipClusterPtr, NOCResponseCallback Callback + , byte[] NOCValue, Optional ICACValue + , @Nullable Integer timedInvokeTimeoutMs); public interface AttestationResponseCallback { void onSuccess(byte[] attestationElements, byte[] signature); - + void onError(Exception error); } public interface CertificateChainResponseCallback { void onSuccess(byte[] certificate); - + void onError(Exception error); } public interface NOCResponseCallback { void onSuccess(Integer statusCode, Integer fabricIndex, String debugText); - + void onError(Exception error); } public interface OpCSRResponseCallback { void onSuccess(byte[] NOCSRElements, byte[] attestationSignature); - + void onError(Exception error); } - public interface NOCsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface FabricsListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface TrustedRootCertificatesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentFabricIndexAttributeCallback { - void onSuccess(Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface NOCsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface FabricsListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface TrustedRootCertificatesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentFabricIndexAttributeCallback { + void onSuccess( Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readNOCsAttribute(NOCsAttributeCallback callback) { + public void readNOCsAttribute( + NOCsAttributeCallback callback + ) { readNOCsAttribute(chipClusterPtr, callback); } - public void subscribeNOCsAttribute( - NOCsAttributeCallback callback, int minInterval, int maxInterval) { + NOCsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNOCsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFabricsListAttribute(FabricsListAttributeCallback callback) { + public void readFabricsListAttribute( + FabricsListAttributeCallback callback + ) { readFabricsListAttribute(chipClusterPtr, callback); } - public void subscribeFabricsListAttribute( - FabricsListAttributeCallback callback, int minInterval, int maxInterval) { + FabricsListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeFabricsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedFabricsAttribute(IntegerAttributeCallback callback) { + public void readSupportedFabricsAttribute( + IntegerAttributeCallback callback + ) { readSupportedFabricsAttribute(chipClusterPtr, callback); } - public void subscribeSupportedFabricsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSupportedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCommissionedFabricsAttribute(IntegerAttributeCallback callback) { + public void readCommissionedFabricsAttribute( + IntegerAttributeCallback callback + ) { readCommissionedFabricsAttribute(chipClusterPtr, callback); } - public void subscribeCommissionedFabricsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCommissionedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTrustedRootCertificatesAttribute( - TrustedRootCertificatesAttributeCallback callback) { + TrustedRootCertificatesAttributeCallback callback + ) { readTrustedRootCertificatesAttribute(chipClusterPtr, callback); } - public void subscribeTrustedRootCertificatesAttribute( - TrustedRootCertificatesAttributeCallback callback, int minInterval, int maxInterval) { + TrustedRootCertificatesAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeTrustedRootCertificatesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentFabricIndexAttribute(CurrentFabricIndexAttributeCallback callback) { + public void readCurrentFabricIndexAttribute( + CurrentFabricIndexAttributeCallback callback + ) { readCurrentFabricIndexAttribute(chipClusterPtr, callback); } - public void subscribeCurrentFabricIndexAttribute( - CurrentFabricIndexAttributeCallback callback, int minInterval, int maxInterval) { + CurrentFabricIndexAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeCurrentFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNOCsAttribute(long chipClusterPtr, NOCsAttributeCallback callback); - - private native void subscribeNOCsAttribute( - long chipClusterPtr, NOCsAttributeCallback callback, int minInterval, int maxInterval); - - private native void readFabricsListAttribute( - long chipClusterPtr, FabricsListAttributeCallback callback); - - private native void subscribeFabricsListAttribute( - long chipClusterPtr, - FabricsListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSupportedFabricsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSupportedFabricsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCommissionedFabricsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCommissionedFabricsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTrustedRootCertificatesAttribute( - long chipClusterPtr, TrustedRootCertificatesAttributeCallback callback); - - private native void subscribeTrustedRootCertificatesAttribute( - long chipClusterPtr, - TrustedRootCertificatesAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentFabricIndexAttribute( - long chipClusterPtr, CurrentFabricIndexAttributeCallback callback); - - private native void subscribeCurrentFabricIndexAttribute( - long chipClusterPtr, - CurrentFabricIndexAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readNOCsAttribute(long chipClusterPtr, + NOCsAttributeCallback callback + ); + private native void subscribeNOCsAttribute(long chipClusterPtr, + NOCsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFabricsListAttribute(long chipClusterPtr, + FabricsListAttributeCallback callback + ); + private native void subscribeFabricsListAttribute(long chipClusterPtr, + FabricsListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSupportedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSupportedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCommissionedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCommissionedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTrustedRootCertificatesAttribute(long chipClusterPtr, + TrustedRootCertificatesAttributeCallback callback + ); + private native void subscribeTrustedRootCertificatesAttribute(long chipClusterPtr, + TrustedRootCertificatesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentFabricIndexAttribute(long chipClusterPtr, + CurrentFabricIndexAttributeCallback callback + ); + private native void subscribeCurrentFabricIndexAttribute(long chipClusterPtr, + CurrentFabricIndexAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class PowerSourceCluster extends BaseChipCluster { @@ -10445,208 +9520,244 @@ public PowerSourceCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface ActiveBatteryFaultsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface ActiveBatteryFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readStatusAttribute(IntegerAttributeCallback callback) { + public void readStatusAttribute( + IntegerAttributeCallback callback + ) { readStatusAttribute(chipClusterPtr, callback); } - public void subscribeStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOrderAttribute(IntegerAttributeCallback callback) { + public void readOrderAttribute( + IntegerAttributeCallback callback + ) { readOrderAttribute(chipClusterPtr, callback); } - public void subscribeOrderAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOrderAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDescriptionAttribute(CharStringAttributeCallback callback) { + public void readDescriptionAttribute( + CharStringAttributeCallback callback + ) { readDescriptionAttribute(chipClusterPtr, callback); } - public void subscribeDescriptionAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryVoltageAttribute(LongAttributeCallback callback) { + public void readBatteryVoltageAttribute( + LongAttributeCallback callback + ) { readBatteryVoltageAttribute(chipClusterPtr, callback); } - public void subscribeBatteryVoltageAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBatteryVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryPercentRemainingAttribute(IntegerAttributeCallback callback) { + public void readBatteryPercentRemainingAttribute( + IntegerAttributeCallback callback + ) { readBatteryPercentRemainingAttribute(chipClusterPtr, callback); } - public void subscribeBatteryPercentRemainingAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBatteryPercentRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryTimeRemainingAttribute(LongAttributeCallback callback) { + public void readBatteryTimeRemainingAttribute( + LongAttributeCallback callback + ) { readBatteryTimeRemainingAttribute(chipClusterPtr, callback); } - public void subscribeBatteryTimeRemainingAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBatteryTimeRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryChargeLevelAttribute(IntegerAttributeCallback callback) { + public void readBatteryChargeLevelAttribute( + IntegerAttributeCallback callback + ) { readBatteryChargeLevelAttribute(chipClusterPtr, callback); } - public void subscribeBatteryChargeLevelAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBatteryChargeLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveBatteryFaultsAttribute(ActiveBatteryFaultsAttributeCallback callback) { + public void readActiveBatteryFaultsAttribute( + ActiveBatteryFaultsAttributeCallback callback + ) { readActiveBatteryFaultsAttribute(chipClusterPtr, callback); } - public void subscribeActiveBatteryFaultsAttribute( - ActiveBatteryFaultsAttributeCallback callback, int minInterval, int maxInterval) { + ActiveBatteryFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeActiveBatteryFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryChargeStateAttribute(IntegerAttributeCallback callback) { + public void readBatteryChargeStateAttribute( + IntegerAttributeCallback callback + ) { readBatteryChargeStateAttribute(chipClusterPtr, callback); } - public void subscribeBatteryChargeStateAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBatteryChargeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readStatusAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOrderAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeOrderAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDescriptionAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeDescriptionAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readBatteryVoltageAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeBatteryVoltageAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBatteryPercentRemainingAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBatteryPercentRemainingAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBatteryTimeRemainingAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeBatteryTimeRemainingAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBatteryChargeLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBatteryChargeLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActiveBatteryFaultsAttribute( - long chipClusterPtr, ActiveBatteryFaultsAttributeCallback callback); - - private native void subscribeActiveBatteryFaultsAttribute( - long chipClusterPtr, - ActiveBatteryFaultsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readBatteryChargeStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBatteryChargeStateAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOrderAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOrderAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatteryVoltageAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeBatteryVoltageAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatteryPercentRemainingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatteryPercentRemainingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatteryTimeRemainingAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeBatteryTimeRemainingAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatteryChargeLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatteryChargeLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveBatteryFaultsAttribute(long chipClusterPtr, + ActiveBatteryFaultsAttributeCallback callback + ); + private native void subscribeActiveBatteryFaultsAttribute(long chipClusterPtr, + ActiveBatteryFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readBatteryChargeStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatteryChargeStateAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 PowerSourceConfigurationCluster extends BaseChipCluster { @@ -10659,69 +9770,73 @@ public PowerSourceConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SourcesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface SourcesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readSourcesAttribute(SourcesAttributeCallback callback) { + public void readSourcesAttribute( + SourcesAttributeCallback callback + ) { readSourcesAttribute(chipClusterPtr, callback); } - public void subscribeSourcesAttribute( - SourcesAttributeCallback callback, int minInterval, int maxInterval) { + SourcesAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeSourcesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSourcesAttribute( - long chipClusterPtr, SourcesAttributeCallback callback); - - private native void subscribeSourcesAttribute( - long chipClusterPtr, SourcesAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readSourcesAttribute(long chipClusterPtr, + SourcesAttributeCallback callback + ); + private native void subscribeSourcesAttribute(long chipClusterPtr, + SourcesAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class PressureMeasurementCluster extends BaseChipCluster { @@ -10734,91 +9849,106 @@ public PressureMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMinMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMaxMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class PumpConfigurationAndControlCluster extends BaseChipCluster { @@ -10831,614 +9961,701 @@ public PumpConfigurationAndControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LifetimeRunningHoursAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface LifetimeEnergyConsumedAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface LifetimeRunningHoursAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface LifetimeEnergyConsumedAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMaxPressureAttribute(IntegerAttributeCallback callback) { + public void readMaxPressureAttribute( + IntegerAttributeCallback callback + ) { readMaxPressureAttribute(chipClusterPtr, callback); } - public void subscribeMaxPressureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxSpeedAttribute(IntegerAttributeCallback callback) { + public void readMaxSpeedAttribute( + IntegerAttributeCallback callback + ) { readMaxSpeedAttribute(chipClusterPtr, callback); } - public void subscribeMaxSpeedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxFlowAttribute(IntegerAttributeCallback callback) { + public void readMaxFlowAttribute( + IntegerAttributeCallback callback + ) { readMaxFlowAttribute(chipClusterPtr, callback); } - public void subscribeMaxFlowAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstPressureAttribute(IntegerAttributeCallback callback) { + public void readMinConstPressureAttribute( + IntegerAttributeCallback callback + ) { readMinConstPressureAttribute(chipClusterPtr, callback); } - public void subscribeMinConstPressureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstPressureAttribute(IntegerAttributeCallback callback) { + public void readMaxConstPressureAttribute( + IntegerAttributeCallback callback + ) { readMaxConstPressureAttribute(chipClusterPtr, callback); } - public void subscribeMaxConstPressureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinCompPressureAttribute(IntegerAttributeCallback callback) { + public void readMinCompPressureAttribute( + IntegerAttributeCallback callback + ) { readMinCompPressureAttribute(chipClusterPtr, callback); } - public void subscribeMinCompPressureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxCompPressureAttribute(IntegerAttributeCallback callback) { + public void readMaxCompPressureAttribute( + IntegerAttributeCallback callback + ) { readMaxCompPressureAttribute(chipClusterPtr, callback); } - public void subscribeMaxCompPressureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstSpeedAttribute(IntegerAttributeCallback callback) { + public void readMinConstSpeedAttribute( + IntegerAttributeCallback callback + ) { readMinConstSpeedAttribute(chipClusterPtr, callback); } - public void subscribeMinConstSpeedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstSpeedAttribute(IntegerAttributeCallback callback) { + public void readMaxConstSpeedAttribute( + IntegerAttributeCallback callback + ) { readMaxConstSpeedAttribute(chipClusterPtr, callback); } - public void subscribeMaxConstSpeedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstFlowAttribute(IntegerAttributeCallback callback) { + public void readMinConstFlowAttribute( + IntegerAttributeCallback callback + ) { readMinConstFlowAttribute(chipClusterPtr, callback); } - public void subscribeMinConstFlowAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstFlowAttribute(IntegerAttributeCallback callback) { + public void readMaxConstFlowAttribute( + IntegerAttributeCallback callback + ) { readMaxConstFlowAttribute(chipClusterPtr, callback); } - public void subscribeMaxConstFlowAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstTempAttribute(IntegerAttributeCallback callback) { + public void readMinConstTempAttribute( + IntegerAttributeCallback callback + ) { readMinConstTempAttribute(chipClusterPtr, callback); } - public void subscribeMinConstTempAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstTempAttribute(IntegerAttributeCallback callback) { + public void readMaxConstTempAttribute( + IntegerAttributeCallback callback + ) { readMaxConstTempAttribute(chipClusterPtr, callback); } - public void subscribeMaxConstTempAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPumpStatusAttribute(IntegerAttributeCallback callback) { + public void readPumpStatusAttribute( + IntegerAttributeCallback callback + ) { readPumpStatusAttribute(chipClusterPtr, callback); } - public void subscribePumpStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePumpStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEffectiveOperationModeAttribute(IntegerAttributeCallback callback) { + public void readEffectiveOperationModeAttribute( + IntegerAttributeCallback callback + ) { readEffectiveOperationModeAttribute(chipClusterPtr, callback); } - public void subscribeEffectiveOperationModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEffectiveOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEffectiveControlModeAttribute(IntegerAttributeCallback callback) { + public void readEffectiveControlModeAttribute( + IntegerAttributeCallback callback + ) { readEffectiveControlModeAttribute(chipClusterPtr, callback); } - public void subscribeEffectiveControlModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEffectiveControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCapacityAttribute(IntegerAttributeCallback callback) { + public void readCapacityAttribute( + IntegerAttributeCallback callback + ) { readCapacityAttribute(chipClusterPtr, callback); } - public void subscribeCapacityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSpeedAttribute(IntegerAttributeCallback callback) { + public void readSpeedAttribute( + IntegerAttributeCallback callback + ) { readSpeedAttribute(chipClusterPtr, callback); } - public void subscribeSpeedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLifetimeRunningHoursAttribute(LifetimeRunningHoursAttributeCallback callback) { + public void readLifetimeRunningHoursAttribute( + LifetimeRunningHoursAttributeCallback callback + ) { readLifetimeRunningHoursAttribute(chipClusterPtr, callback); } - public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value) { writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, null); } - public void writeLifetimeRunningHoursAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLifetimeRunningHoursAttribute( - LifetimeRunningHoursAttributeCallback callback, int minInterval, int maxInterval) { + LifetimeRunningHoursAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLifetimeRunningHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPowerAttribute(LongAttributeCallback callback) { + public void readPowerAttribute( + LongAttributeCallback callback + ) { readPowerAttribute(chipClusterPtr, callback); } - public void subscribePowerAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readLifetimeEnergyConsumedAttribute( - LifetimeEnergyConsumedAttributeCallback callback) { + LifetimeEnergyConsumedAttributeCallback callback + ) { readLifetimeEnergyConsumedAttribute(chipClusterPtr, callback); } - public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value) { writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, null); } - public void writeLifetimeEnergyConsumedAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLifetimeEnergyConsumedAttribute( - LifetimeEnergyConsumedAttributeCallback callback, int minInterval, int maxInterval) { + LifetimeEnergyConsumedAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperationModeAttribute(IntegerAttributeCallback callback) { + public void readOperationModeAttribute( + IntegerAttributeCallback callback + ) { readOperationModeAttribute(chipClusterPtr, callback); } - public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value) { writeOperationModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOperationModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOperationModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOperationModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readControlModeAttribute(IntegerAttributeCallback callback) { + public void readControlModeAttribute( + IntegerAttributeCallback callback + ) { readControlModeAttribute(chipClusterPtr, callback); } - public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value) { writeControlModeAttribute(chipClusterPtr, callback, value, null); } - public void writeControlModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeControlModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeControlModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAlarmMaskAttribute(IntegerAttributeCallback callback) { + public void readAlarmMaskAttribute( + IntegerAttributeCallback callback + ) { readAlarmMaskAttribute(chipClusterPtr, callback); } - public void subscribeAlarmMaskAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAlarmMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMaxPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + private native void readMaxPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinConstPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinConstPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxConstPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxConstPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinCompPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinCompPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxCompPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxCompPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinConstSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinConstSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxConstSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxConstSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinConstFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinConstFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxConstFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxConstFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinConstTempAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinConstTempAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxConstTempAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxConstTempAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPumpStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePumpStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEffectiveOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEffectiveOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEffectiveControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEffectiveControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCapacityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCapacityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLifetimeRunningHoursAttribute(long chipClusterPtr, + LifetimeRunningHoursAttributeCallback callback + ); + + private native void writeLifetimeRunningHoursAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLifetimeRunningHoursAttribute(long chipClusterPtr, + LifetimeRunningHoursAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPowerAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePowerAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLifetimeEnergyConsumedAttribute(long chipClusterPtr, + LifetimeEnergyConsumedAttributeCallback callback + ); + + private native void writeLifetimeEnergyConsumedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLifetimeEnergyConsumedAttribute(long chipClusterPtr, + LifetimeEnergyConsumedAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOperationModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeControlModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAlarmMaskAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAlarmMaskAttribute(long chipClusterPtr, + IntegerAttributeCallback 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); + } - private native void subscribeMaxSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public static class RelativeHumidityMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1029L; - private native void readMaxFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } - private native void subscribeMaxFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + @Override + public native long initWithDevice(long devicePtr, int endpointId); - private native void readMinConstPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void subscribeMinConstPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public void readMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readMaxConstPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxConstPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinCompPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinCompPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxCompPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxCompPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinConstSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinConstSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxConstSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxConstSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinConstFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinConstFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxConstFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxConstFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinConstTempAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinConstTempAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxConstTempAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxConstTempAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPumpStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePumpStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEffectiveOperationModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeEffectiveOperationModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEffectiveControlModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeEffectiveControlModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCapacityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCapacityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSpeedAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLifetimeRunningHoursAttribute( - long chipClusterPtr, LifetimeRunningHoursAttributeCallback callback); - - private native void writeLifetimeRunningHoursAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLifetimeRunningHoursAttribute( - long chipClusterPtr, - LifetimeRunningHoursAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readPowerAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePowerAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLifetimeEnergyConsumedAttribute( - long chipClusterPtr, LifetimeEnergyConsumedAttributeCallback callback); - - private native void writeLifetimeEnergyConsumedAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLifetimeEnergyConsumedAttribute( - long chipClusterPtr, - LifetimeEnergyConsumedAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOperationModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOperationModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOperationModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readControlModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeControlModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeControlModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAlarmMaskAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAlarmMaskAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 RelativeHumidityMeasurementCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1029L; - - public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } - - @Override - public native long initWithDevice(long devicePtr, int endpointId); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { - readMeasuredValueAttribute(chipClusterPtr, callback); - } - - public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMinMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMaxMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute(IntegerAttributeCallback callback) { + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { readToleranceAttribute(chipClusterPtr, callback); } - public void subscribeToleranceAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ScenesCluster extends BaseChipCluster { @@ -11451,325 +10668,278 @@ public ScenesCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addScene( - AddSceneResponseCallback callback, - Integer groupId, - Integer sceneId, - Integer transitionTime, - String sceneName, - ArrayList extensionFieldSets) { - addScene( - chipClusterPtr, - callback, - groupId, - sceneId, - transitionTime, - sceneName, - extensionFieldSets, - null); - } - - public void addScene( - AddSceneResponseCallback callback, - Integer groupId, - Integer sceneId, - Integer transitionTime, - String sceneName, - ArrayList extensionFieldSets, - int timedInvokeTimeoutMs) { - addScene( - chipClusterPtr, - callback, - groupId, - sceneId, - transitionTime, - sceneName, - extensionFieldSets, - timedInvokeTimeoutMs); - } - - public void getSceneMembership(GetSceneMembershipResponseCallback callback, Integer groupId) { + public void addScene(AddSceneResponseCallback callback + , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { + addScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, sceneName, extensionFieldSets, null); + } + + public void addScene(AddSceneResponseCallback callback + , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets + , int timedInvokeTimeoutMs) { + addScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, sceneName, extensionFieldSets, timedInvokeTimeoutMs); + } + + public void getSceneMembership(GetSceneMembershipResponseCallback callback + , Integer groupId) { getSceneMembership(chipClusterPtr, callback, groupId, null); } - public void getSceneMembership( - GetSceneMembershipResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { + public void getSceneMembership(GetSceneMembershipResponseCallback callback + , Integer groupId + , int timedInvokeTimeoutMs) { getSceneMembership(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void recallScene( - DefaultClusterCallback callback, Integer groupId, Integer sceneId, Integer transitionTime) { + public void recallScene(DefaultClusterCallback callback + , Integer groupId, Integer sceneId, Integer transitionTime) { recallScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, null); } - public void recallScene( - DefaultClusterCallback callback, - Integer groupId, - Integer sceneId, - Integer transitionTime, - int timedInvokeTimeoutMs) { + public void recallScene(DefaultClusterCallback callback + , Integer groupId, Integer sceneId, Integer transitionTime + , int timedInvokeTimeoutMs) { recallScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, timedInvokeTimeoutMs); } - public void removeAllScenes(RemoveAllScenesResponseCallback callback, Integer groupId) { + public void removeAllScenes(RemoveAllScenesResponseCallback callback + , Integer groupId) { removeAllScenes(chipClusterPtr, callback, groupId, null); } - public void removeAllScenes( - RemoveAllScenesResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { + public void removeAllScenes(RemoveAllScenesResponseCallback callback + , Integer groupId + , int timedInvokeTimeoutMs) { removeAllScenes(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void removeScene( - RemoveSceneResponseCallback callback, Integer groupId, Integer sceneId) { + public void removeScene(RemoveSceneResponseCallback callback + , Integer groupId, Integer sceneId) { removeScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void removeScene( - RemoveSceneResponseCallback callback, - Integer groupId, - Integer sceneId, - int timedInvokeTimeoutMs) { + public void removeScene(RemoveSceneResponseCallback callback + , Integer groupId, Integer sceneId + , int timedInvokeTimeoutMs) { removeScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - public void storeScene(StoreSceneResponseCallback callback, Integer groupId, Integer sceneId) { + public void storeScene(StoreSceneResponseCallback callback + , Integer groupId, Integer sceneId) { storeScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void storeScene( - StoreSceneResponseCallback callback, - Integer groupId, - Integer sceneId, - int timedInvokeTimeoutMs) { + public void storeScene(StoreSceneResponseCallback callback + , Integer groupId, Integer sceneId + , int timedInvokeTimeoutMs) { storeScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - public void viewScene(ViewSceneResponseCallback callback, Integer groupId, Integer sceneId) { + public void viewScene(ViewSceneResponseCallback callback + , Integer groupId, Integer sceneId) { viewScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void viewScene( - ViewSceneResponseCallback callback, - Integer groupId, - Integer sceneId, - int timedInvokeTimeoutMs) { + public void viewScene(ViewSceneResponseCallback callback + , Integer groupId, Integer sceneId + , int timedInvokeTimeoutMs) { viewScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - - private native void addScene( - long chipClusterPtr, - AddSceneResponseCallback Callback, - Integer groupId, - Integer sceneId, - Integer transitionTime, - String sceneName, - ArrayList extensionFieldSets, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getSceneMembership( - long chipClusterPtr, - GetSceneMembershipResponseCallback Callback, - Integer groupId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void recallScene( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer groupId, - Integer sceneId, - Integer transitionTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeAllScenes( - long chipClusterPtr, - RemoveAllScenesResponseCallback Callback, - Integer groupId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeScene( - long chipClusterPtr, - RemoveSceneResponseCallback Callback, - Integer groupId, - Integer sceneId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void storeScene( - long chipClusterPtr, - StoreSceneResponseCallback Callback, - Integer groupId, - Integer sceneId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void viewScene( - long chipClusterPtr, - ViewSceneResponseCallback Callback, - Integer groupId, - Integer sceneId, - @Nullable Integer timedInvokeTimeoutMs); - + private native void addScene(long chipClusterPtr, AddSceneResponseCallback Callback + , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets + , @Nullable Integer timedInvokeTimeoutMs); + private native void getSceneMembership(long chipClusterPtr, GetSceneMembershipResponseCallback Callback + , Integer groupId + , @Nullable Integer timedInvokeTimeoutMs); + private native void recallScene(long chipClusterPtr, DefaultClusterCallback Callback + , Integer groupId, Integer sceneId, Integer transitionTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeAllScenes(long chipClusterPtr, RemoveAllScenesResponseCallback Callback + , Integer groupId + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeScene(long chipClusterPtr, RemoveSceneResponseCallback Callback + , Integer groupId, Integer sceneId + , @Nullable Integer timedInvokeTimeoutMs); + private native void storeScene(long chipClusterPtr, StoreSceneResponseCallback Callback + , Integer groupId, Integer sceneId + , @Nullable Integer timedInvokeTimeoutMs); + private native void viewScene(long chipClusterPtr, ViewSceneResponseCallback Callback + , Integer groupId, Integer sceneId + , @Nullable Integer timedInvokeTimeoutMs); public interface AddSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface GetSceneMembershipResponseCallback { - void onSuccess( - Integer status, - Integer capacity, - Integer groupId, - Integer sceneCount, - ArrayList sceneList); - + void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList); + void onError(Exception error); } public interface RemoveAllScenesResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface RemoveSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface StoreSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface ViewSceneResponseCallback { - void onSuccess( - Integer status, - Integer groupId, - Integer sceneId, - Integer transitionTime, - String sceneName, - ArrayList extensionFieldSets); - + void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets); + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readSceneCountAttribute(IntegerAttributeCallback callback) { + public void readSceneCountAttribute( + IntegerAttributeCallback callback + ) { readSceneCountAttribute(chipClusterPtr, callback); } - public void subscribeSceneCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSceneCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentSceneAttribute(IntegerAttributeCallback callback) { + public void readCurrentSceneAttribute( + IntegerAttributeCallback callback + ) { readCurrentSceneAttribute(chipClusterPtr, callback); } - public void subscribeCurrentSceneAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentSceneAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentGroupAttribute(IntegerAttributeCallback callback) { + public void readCurrentGroupAttribute( + IntegerAttributeCallback callback + ) { readCurrentGroupAttribute(chipClusterPtr, callback); } - public void subscribeCurrentGroupAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentGroupAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSceneValidAttribute(BooleanAttributeCallback callback) { + public void readSceneValidAttribute( + BooleanAttributeCallback callback + ) { readSceneValidAttribute(chipClusterPtr, callback); } - public void subscribeSceneValidAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSceneValidAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNameSupportAttribute(IntegerAttributeCallback callback) { + public void readNameSupportAttribute( + IntegerAttributeCallback callback + ) { readNameSupportAttribute(chipClusterPtr, callback); } - public void subscribeNameSupportAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSceneCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSceneCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentSceneAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentSceneAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentGroupAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentGroupAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSceneValidAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeSceneValidAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNameSupportAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNameSupportAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readSceneCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSceneCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentSceneAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentSceneAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentGroupAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentGroupAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSceneValidAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeSceneValidAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class SoftwareDiagnosticsCluster extends BaseChipCluster { @@ -11782,147 +10952,163 @@ public SoftwareDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetWatermarks(DefaultClusterCallback callback) { + public void resetWatermarks(DefaultClusterCallback callback + ) { resetWatermarks(chipClusterPtr, callback, null); } - public void resetWatermarks(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void resetWatermarks(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { resetWatermarks(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void resetWatermarks(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); - private native void resetWatermarks( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface ThreadMetricsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface ThreadMetricsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readThreadMetricsAttribute(ThreadMetricsAttributeCallback callback) { + public void readThreadMetricsAttribute( + ThreadMetricsAttributeCallback callback + ) { readThreadMetricsAttribute(chipClusterPtr, callback); } - public void subscribeThreadMetricsAttribute( - ThreadMetricsAttributeCallback callback, int minInterval, int maxInterval) { + ThreadMetricsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeThreadMetricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapFreeAttribute(LongAttributeCallback callback) { + public void readCurrentHeapFreeAttribute( + LongAttributeCallback callback + ) { readCurrentHeapFreeAttribute(chipClusterPtr, callback); } - public void subscribeCurrentHeapFreeAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentHeapFreeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapUsedAttribute(LongAttributeCallback callback) { + public void readCurrentHeapUsedAttribute( + LongAttributeCallback callback + ) { readCurrentHeapUsedAttribute(chipClusterPtr, callback); } - public void subscribeCurrentHeapUsedAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentHeapUsedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapHighWatermarkAttribute(LongAttributeCallback callback) { + public void readCurrentHeapHighWatermarkAttribute( + LongAttributeCallback callback + ) { readCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback); } - public void subscribeCurrentHeapHighWatermarkAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeCurrentHeapHighWatermarkAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readThreadMetricsAttribute( - long chipClusterPtr, ThreadMetricsAttributeCallback callback); - - private native void subscribeThreadMetricsAttribute( - long chipClusterPtr, - ThreadMetricsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentHeapFreeAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeCurrentHeapFreeAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentHeapUsedAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeCurrentHeapUsedAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentHeapHighWatermarkAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeCurrentHeapHighWatermarkAttribute( - long chipClusterPtr, LongAttributeCallback 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); + private native void readThreadMetricsAttribute(long chipClusterPtr, + ThreadMetricsAttributeCallback callback + ); + private native void subscribeThreadMetricsAttribute(long chipClusterPtr, + ThreadMetricsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentHeapFreeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCurrentHeapFreeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentHeapUsedAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCurrentHeapUsedAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentHeapHighWatermarkAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCurrentHeapHighWatermarkAttribute(long chipClusterPtr, + LongAttributeCallback 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 SwitchCluster extends BaseChipCluster { @@ -11935,106 +11121,125 @@ public SwitchCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readNumberOfPositionsAttribute(IntegerAttributeCallback callback) { + public void readNumberOfPositionsAttribute( + IntegerAttributeCallback callback + ) { readNumberOfPositionsAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfPositionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNumberOfPositionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionAttribute(IntegerAttributeCallback callback) { + public void readCurrentPositionAttribute( + IntegerAttributeCallback callback + ) { readCurrentPositionAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMultiPressMaxAttribute(IntegerAttributeCallback callback) { + public void readMultiPressMaxAttribute( + IntegerAttributeCallback callback + ) { readMultiPressMaxAttribute(chipClusterPtr, callback); } - public void subscribeMultiPressMaxAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMultiPressMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNumberOfPositionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfPositionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentPositionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentPositionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMultiPressMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMultiPressMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readNumberOfPositionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfPositionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMultiPressMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMultiPressMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 TargetNavigatorCluster extends BaseChipCluster { @@ -12047,113 +11252,112 @@ public TargetNavigatorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void navigateTargetRequest( - NavigateTargetResponseCallback callback, Integer target, String data) { + public void navigateTargetRequest(NavigateTargetResponseCallback callback + , Integer target, String data) { navigateTargetRequest(chipClusterPtr, callback, target, data, null); } - public void navigateTargetRequest( - NavigateTargetResponseCallback callback, - Integer target, - String data, - int timedInvokeTimeoutMs) { + public void navigateTargetRequest(NavigateTargetResponseCallback callback + , Integer target, String data + , int timedInvokeTimeoutMs) { navigateTargetRequest(chipClusterPtr, callback, target, data, timedInvokeTimeoutMs); } - - private native void navigateTargetRequest( - long chipClusterPtr, - NavigateTargetResponseCallback Callback, - Integer target, - String data, - @Nullable Integer timedInvokeTimeoutMs); - + private native void navigateTargetRequest(long chipClusterPtr, NavigateTargetResponseCallback Callback + , Integer target, String data + , @Nullable Integer timedInvokeTimeoutMs); public interface NavigateTargetResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } - public interface TargetNavigatorListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface TargetNavigatorListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readTargetNavigatorListAttribute(TargetNavigatorListAttributeCallback callback) { + public void readTargetNavigatorListAttribute( + TargetNavigatorListAttributeCallback callback + ) { readTargetNavigatorListAttribute(chipClusterPtr, callback); } - public void subscribeTargetNavigatorListAttribute( - TargetNavigatorListAttributeCallback callback, int minInterval, int maxInterval) { + TargetNavigatorListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeTargetNavigatorListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentNavigatorTargetAttribute(IntegerAttributeCallback callback) { + public void readCurrentNavigatorTargetAttribute( + IntegerAttributeCallback callback + ) { readCurrentNavigatorTargetAttribute(chipClusterPtr, callback); } - public void subscribeCurrentNavigatorTargetAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentNavigatorTargetAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTargetNavigatorListAttribute( - long chipClusterPtr, TargetNavigatorListAttributeCallback callback); - - private native void subscribeTargetNavigatorListAttribute( - long chipClusterPtr, - TargetNavigatorListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentNavigatorTargetAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentNavigatorTargetAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readTargetNavigatorListAttribute(long chipClusterPtr, + TargetNavigatorListAttributeCallback callback + ); + private native void subscribeTargetNavigatorListAttribute(long chipClusterPtr, + TargetNavigatorListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentNavigatorTargetAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentNavigatorTargetAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class TemperatureMeasurementCluster extends BaseChipCluster { @@ -12166,3268 +11370,2838 @@ public TemperatureMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMinMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMaxMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute(IntegerAttributeCallback callback) { + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { readToleranceAttribute(chipClusterPtr, callback); } - public void subscribeToleranceAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + 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 readMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - } - - public static class TestClusterCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1295L; - - public TestClusterCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } - - @Override - public native long initWithDevice(long devicePtr, int endpointId); - - public void simpleStructEchoRequest( - SimpleStructResponseCallback callback, ChipStructs.TestClusterClusterSimpleStruct arg1) { - simpleStructEchoRequest(chipClusterPtr, callback, arg1, null); - } - - public void simpleStructEchoRequest( - SimpleStructResponseCallback callback, - ChipStructs.TestClusterClusterSimpleStruct arg1, - int timedInvokeTimeoutMs) { - simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void test(DefaultClusterCallback callback) { - test(chipClusterPtr, callback, null); - } - - public void test(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - test(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - public void testAddArguments( - TestAddArgumentsResponseCallback callback, Integer arg1, Integer arg2) { - testAddArguments(chipClusterPtr, callback, arg1, arg2, null); - } - - public void testAddArguments( - TestAddArgumentsResponseCallback callback, - Integer arg1, - Integer arg2, - int timedInvokeTimeoutMs) { - testAddArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); - } - - public void testEmitTestEventRequest( - TestEmitTestEventResponseCallback callback, Integer arg1, Integer arg2, Boolean arg3) { - testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, null); - } - - public void testEmitTestEventRequest( - TestEmitTestEventResponseCallback callback, - Integer arg1, - Integer arg2, - Boolean arg3, - int timedInvokeTimeoutMs) { - testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, timedInvokeTimeoutMs); - } - - public void testEnumsRequest(TestEnumsResponseCallback callback, Integer arg1, Integer arg2) { - testEnumsRequest(chipClusterPtr, callback, arg1, arg2, null); - } - - public void testEnumsRequest( - TestEnumsResponseCallback callback, Integer arg1, Integer arg2, int timedInvokeTimeoutMs) { - testEnumsRequest(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); - } - - public void testListInt8UArgumentRequest( - BooleanResponseCallback callback, ArrayList arg1) { - testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testListInt8UArgumentRequest( - BooleanResponseCallback callback, ArrayList arg1, int timedInvokeTimeoutMs) { - testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testListInt8UReverseRequest( - TestListInt8UReverseResponseCallback callback, ArrayList arg1) { - testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null); - } - - public void testListInt8UReverseRequest( - TestListInt8UReverseResponseCallback callback, - ArrayList arg1, - int timedInvokeTimeoutMs) { - testListInt8UReverseRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testListNestedStructListArgumentRequest( - BooleanResponseCallback callback, - ArrayList arg1) { - testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testListNestedStructListArgumentRequest( - BooleanResponseCallback callback, - ArrayList arg1, - int timedInvokeTimeoutMs) { - testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testListStructArgumentRequest( - BooleanResponseCallback callback, - ArrayList arg1) { - testListStructArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testListStructArgumentRequest( - BooleanResponseCallback callback, - ArrayList arg1, - int timedInvokeTimeoutMs) { - testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testNestedStructArgumentRequest( - BooleanResponseCallback callback, ChipStructs.TestClusterClusterNestedStruct arg1) { - testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testNestedStructArgumentRequest( - BooleanResponseCallback callback, - ChipStructs.TestClusterClusterNestedStruct arg1, - int timedInvokeTimeoutMs) { - testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testNestedStructListArgumentRequest( - BooleanResponseCallback callback, ChipStructs.TestClusterClusterNestedStructList arg1) { - testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testNestedStructListArgumentRequest( - BooleanResponseCallback callback, - ChipStructs.TestClusterClusterNestedStructList arg1, - int timedInvokeTimeoutMs) { - testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testNotHandled(DefaultClusterCallback callback) { - testNotHandled(chipClusterPtr, callback, null); - } - - public void testNotHandled(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - public void testNullableOptionalRequest( - TestNullableOptionalResponseCallback callback, @Nullable Optional arg1) { - testNullableOptionalRequest(chipClusterPtr, callback, arg1, null); - } - - public void testNullableOptionalRequest( - TestNullableOptionalResponseCallback callback, - @Nullable Optional arg1, - int timedInvokeTimeoutMs) { - testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testSimpleOptionalArgumentRequest( - DefaultClusterCallback callback, Optional arg1) { - testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testSimpleOptionalArgumentRequest( - DefaultClusterCallback callback, Optional arg1, int timedInvokeTimeoutMs) { - testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testSpecific(TestSpecificResponseCallback callback) { - testSpecific(chipClusterPtr, callback, null); - } - - public void testSpecific(TestSpecificResponseCallback callback, int timedInvokeTimeoutMs) { - - testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - public void testStructArgumentRequest( - BooleanResponseCallback callback, ChipStructs.TestClusterClusterSimpleStruct arg1) { - testStructArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testStructArgumentRequest( - BooleanResponseCallback callback, - ChipStructs.TestClusterClusterSimpleStruct arg1, - int timedInvokeTimeoutMs) { - testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testUnknownCommand(DefaultClusterCallback callback) { - testUnknownCommand(chipClusterPtr, callback, null); - } - - public void testUnknownCommand(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - public void timedInvokeRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - private native void simpleStructEchoRequest( - long chipClusterPtr, - SimpleStructResponseCallback Callback, - ChipStructs.TestClusterClusterSimpleStruct arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void test( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testAddArguments( - long chipClusterPtr, - TestAddArgumentsResponseCallback Callback, - Integer arg1, - Integer arg2, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testEmitTestEventRequest( - long chipClusterPtr, - TestEmitTestEventResponseCallback Callback, - Integer arg1, - Integer arg2, - Boolean arg3, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testEnumsRequest( - long chipClusterPtr, - TestEnumsResponseCallback Callback, - Integer arg1, - Integer arg2, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testListInt8UArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ArrayList arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testListInt8UReverseRequest( - long chipClusterPtr, - TestListInt8UReverseResponseCallback Callback, - ArrayList arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testListNestedStructListArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ArrayList arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testListStructArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ArrayList arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testNestedStructArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ChipStructs.TestClusterClusterNestedStruct arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testNestedStructListArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ChipStructs.TestClusterClusterNestedStructList arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testNotHandled( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testNullableOptionalRequest( - long chipClusterPtr, - TestNullableOptionalResponseCallback Callback, - @Nullable Optional arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testSimpleOptionalArgumentRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Optional arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testSpecific( - long chipClusterPtr, - TestSpecificResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testStructArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ChipStructs.TestClusterClusterSimpleStruct arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testUnknownCommand( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void timedInvokeRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface BooleanResponseCallback { - void onSuccess(Boolean value); - - void onError(Exception error); - } - - public interface SimpleStructResponseCallback { - void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); - - void onError(Exception error); - } - - public interface TestAddArgumentsResponseCallback { - void onSuccess(Integer returnValue); - - void onError(Exception error); - } - - public interface TestEmitTestEventResponseCallback { - void onSuccess(Long value); - - void onError(Exception error); - } - - public interface TestEnumsResponseCallback { - void onSuccess(Integer arg1, Integer arg2); - - void onError(Exception error); - } - - public interface TestListInt8UReverseResponseCallback { - void onSuccess(ArrayList arg1); - - void onError(Exception error); - } - - public interface TestNullableOptionalResponseCallback { - void onSuccess( - Boolean wasPresent, - Optional wasNull, - Optional value, - @Nullable Optional originalValue); - - void onError(Exception error); - } - - public interface TestSpecificResponseCallback { - void onSuccess(Integer returnValue); - - void onError(Exception error); - } - - public interface ListInt8uAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ListOctetStringAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ListStructOctetStringAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface VendorIdAttributeCallback { - void onSuccess(Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ListNullablesAndOptionalsStructAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ListLongOctetStringAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableBooleanAttributeCallback { - void onSuccess(@Nullable Boolean value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableBitmap8AttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableBitmap16AttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableBitmap32AttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableBitmap64AttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt8uAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt16uAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt24uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt32uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt40uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt48uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt56uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt64uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt8sAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt16sAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public interface NullableInt24sAttributeCallback { - void onSuccess(@Nullable Long value); + private native void readMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } - void onError(Exception ex); + public static class TestClusterCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1295L; - default void onSubscriptionEstablished() {} + public TestClusterCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); } - public interface NullableInt32sAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); + @Override + public native long initWithDevice(long devicePtr, int endpointId); - default void onSubscriptionEstablished() {} + public void simpleStructEchoRequest(SimpleStructResponseCallback callback + , ChipStructs.TestClusterClusterSimpleStruct arg1) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, null); } - public interface NullableInt40sAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void simpleStructEchoRequest(SimpleStructResponseCallback callback + , ChipStructs.TestClusterClusterSimpleStruct arg1 + , int timedInvokeTimeoutMs) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); } - public interface NullableInt48sAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void test(DefaultClusterCallback callback + ) { + test(chipClusterPtr, callback, null); } - public interface NullableInt56sAttributeCallback { - void onSuccess(@Nullable Long value); + public void test(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + test(chipClusterPtr, callback, timedInvokeTimeoutMs); + } - void onError(Exception ex); + public void testAddArguments(TestAddArgumentsResponseCallback callback + , Integer arg1, Integer arg2) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, null); + } - default void onSubscriptionEstablished() {} + public void testAddArguments(TestAddArgumentsResponseCallback callback + , Integer arg1, Integer arg2 + , int timedInvokeTimeoutMs) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); } - public interface NullableInt64sAttributeCallback { - void onSuccess(@Nullable Long value); + public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback + , Integer arg1, Integer arg2, Boolean arg3) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, null); + } - void onError(Exception ex); + public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback + , Integer arg1, Integer arg2, Boolean arg3 + , int timedInvokeTimeoutMs) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, timedInvokeTimeoutMs); + } - default void onSubscriptionEstablished() {} + public void testEnumsRequest(TestEnumsResponseCallback callback + , Integer arg1, Integer arg2) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, null); } - public interface NullableEnum8AttributeCallback { - void onSuccess(@Nullable Integer value); + public void testEnumsRequest(TestEnumsResponseCallback callback + , Integer arg1, Integer arg2 + , int timedInvokeTimeoutMs) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + } - void onError(Exception ex); + public void testListInt8UArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null); + } - default void onSubscriptionEstablished() {} + public void testListInt8UArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); } - public interface NullableEnum16AttributeCallback { - void onSuccess(@Nullable Integer value); + public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback + , ArrayList arg1) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null); + } - void onError(Exception ex); + public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - default void onSubscriptionEstablished() {} + public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); } - public interface NullableFloatSingleAttributeCallback { - void onSuccess(@Nullable Float value); + public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - void onError(Exception ex); + public void testListStructArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } - default void onSubscriptionEstablished() {} + public void testListStructArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); } - public interface NullableFloatDoubleAttributeCallback { - void onSuccess(@Nullable Double value); + public void testNestedStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterNestedStruct arg1) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } - void onError(Exception ex); + public void testNestedStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterNestedStruct arg1 + , int timedInvokeTimeoutMs) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - default void onSubscriptionEstablished() {} + public void testNestedStructListArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterNestedStructList arg1) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); } - public interface NullableOctetStringAttributeCallback { - void onSuccess(@Nullable byte[] value); + public void testNestedStructListArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterNestedStructList arg1 + , int timedInvokeTimeoutMs) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - void onError(Exception ex); + public void testNotHandled(DefaultClusterCallback callback + ) { + testNotHandled(chipClusterPtr, callback, null); + } - default void onSubscriptionEstablished() {} + public void testNotHandled(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public interface NullableCharStringAttributeCallback { - void onSuccess(@Nullable String value); + public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback + , @Nullable Optional arg1) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, null); + } - void onError(Exception ex); + public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback + , @Nullable Optional arg1 + , int timedInvokeTimeoutMs) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - default void onSubscriptionEstablished() {} + public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback + , Optional arg1) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null); } - public interface NullableEnumAttrAttributeCallback { - void onSuccess(@Nullable Integer value); + public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback + , Optional arg1 + , int timedInvokeTimeoutMs) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - void onError(Exception ex); + public void testSpecific(TestSpecificResponseCallback callback + ) { + testSpecific(chipClusterPtr, callback, null); + } - default void onSubscriptionEstablished() {} + public void testSpecific(TestSpecificResponseCallback callback + + , int timedInvokeTimeoutMs) { + testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public interface NullableRangeRestrictedInt8uAttributeCallback { - void onSuccess(@Nullable Integer value); + public void testStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterSimpleStruct arg1) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } - void onError(Exception ex); + public void testStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterSimpleStruct arg1 + , int timedInvokeTimeoutMs) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - default void onSubscriptionEstablished() {} + public void testUnknownCommand(DefaultClusterCallback callback + ) { + testUnknownCommand(chipClusterPtr, callback, null); } - public interface NullableRangeRestrictedInt8sAttributeCallback { - void onSuccess(@Nullable Integer value); + public void testUnknownCommand(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); + } - void onError(Exception ex); - default void onSubscriptionEstablished() {} + public void timedInvokeRequest(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void simpleStructEchoRequest(long chipClusterPtr, SimpleStructResponseCallback Callback + , ChipStructs.TestClusterClusterSimpleStruct arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void test(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void testAddArguments(long chipClusterPtr, TestAddArgumentsResponseCallback Callback + , Integer arg1, Integer arg2 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testEmitTestEventRequest(long chipClusterPtr, TestEmitTestEventResponseCallback Callback + , Integer arg1, Integer arg2, Boolean arg3 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testEnumsRequest(long chipClusterPtr, TestEnumsResponseCallback Callback + , Integer arg1, Integer arg2 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListInt8UArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListInt8UReverseRequest(long chipClusterPtr, TestListInt8UReverseResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNestedStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ChipStructs.TestClusterClusterNestedStruct arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ChipStructs.TestClusterClusterNestedStructList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNotHandled(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNullableOptionalRequest(long chipClusterPtr, TestNullableOptionalResponseCallback Callback + , @Nullable Optional arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testSimpleOptionalArgumentRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Optional arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testSpecific(long chipClusterPtr, TestSpecificResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void testStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ChipStructs.TestClusterClusterSimpleStruct arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testUnknownCommand(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void timedInvokeRequest(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + public interface BooleanResponseCallback { + void onSuccess(Boolean value); + + void onError(Exception error); } - public interface NullableRangeRestrictedInt16uAttributeCallback { - void onSuccess(@Nullable Integer value); + public interface SimpleStructResponseCallback { + void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); + + void onError(Exception error); + } - void onError(Exception ex); + public interface TestAddArgumentsResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } - default void onSubscriptionEstablished() {} + public interface TestEmitTestEventResponseCallback { + void onSuccess(Long value); + + void onError(Exception error); } - public interface NullableRangeRestrictedInt16sAttributeCallback { - void onSuccess(@Nullable Integer value); + public interface TestEnumsResponseCallback { + void onSuccess(Integer arg1, Integer arg2); + + void onError(Exception error); + } - void onError(Exception ex); + public interface TestListInt8UReverseResponseCallback { + void onSuccess(ArrayList arg1); + + void onError(Exception error); + } - default void onSubscriptionEstablished() {} + public interface TestNullableOptionalResponseCallback { + void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue); + + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); + public interface TestSpecificResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface ListInt8uAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ListOctetStringAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ListStructOctetStringAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface VendorIdAttributeCallback { + void onSuccess( Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ListNullablesAndOptionalsStructAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ListLongOctetStringAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableBooleanAttributeCallback { + void onSuccess(@Nullable Boolean value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableBitmap8AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableBitmap16AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableBitmap32AttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableBitmap64AttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt24uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt32uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt40uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt48uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt56uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt64uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt24sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt32sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt40sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt48sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt56sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt64sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableEnum8AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableEnum16AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableFloatSingleAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableFloatDoubleAttributeCallback { + void onSuccess(@Nullable Double value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableOctetStringAttributeCallback { + void onSuccess(@Nullable byte[] value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableCharStringAttributeCallback { + void onSuccess(@Nullable String value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableEnumAttrAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableRangeRestrictedInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableRangeRestrictedInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableRangeRestrictedInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableRangeRestrictedInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readBooleanAttribute(BooleanAttributeCallback callback) { + public void readBooleanAttribute( + BooleanAttributeCallback callback + ) { readBooleanAttribute(chipClusterPtr, callback); } - public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeBooleanAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBooleanAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap8Attribute(IntegerAttributeCallback callback) { + public void readBitmap8Attribute( + IntegerAttributeCallback callback + ) { readBitmap8Attribute(chipClusterPtr, callback); } - public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value) { writeBitmap8Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap8Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBitmap8Attribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap16Attribute(IntegerAttributeCallback callback) { + public void readBitmap16Attribute( + IntegerAttributeCallback callback + ) { readBitmap16Attribute(chipClusterPtr, callback); } - public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value) { writeBitmap16Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap16Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBitmap16Attribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap32Attribute(LongAttributeCallback callback) { + public void readBitmap32Attribute( + LongAttributeCallback callback + ) { readBitmap32Attribute(chipClusterPtr, callback); } - public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value) { writeBitmap32Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap32Attribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBitmap32Attribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap64Attribute(LongAttributeCallback callback) { + public void readBitmap64Attribute( + LongAttributeCallback callback + ) { readBitmap64Attribute(chipClusterPtr, callback); } - public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value) { writeBitmap64Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap64Attribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBitmap64Attribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt8uAttribute(IntegerAttributeCallback callback) { + public void readInt8uAttribute( + IntegerAttributeCallback callback + ) { readInt8uAttribute(chipClusterPtr, callback); } - public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt8uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt8uAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt16uAttribute(IntegerAttributeCallback callback) { + public void readInt16uAttribute( + IntegerAttributeCallback callback + ) { readInt16uAttribute(chipClusterPtr, callback); } - public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt16uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt16uAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt24uAttribute(LongAttributeCallback callback) { + public void readInt24uAttribute( + LongAttributeCallback callback + ) { readInt24uAttribute(chipClusterPtr, callback); } - public void writeInt24uAttribute(DefaultClusterCallback callback, Long value) { writeInt24uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt24uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt24uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt32uAttribute(LongAttributeCallback callback) { + public void readInt32uAttribute( + LongAttributeCallback callback + ) { readInt32uAttribute(chipClusterPtr, callback); } - public void writeInt32uAttribute(DefaultClusterCallback callback, Long value) { writeInt32uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt32uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt32uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt40uAttribute(LongAttributeCallback callback) { + public void readInt40uAttribute( + LongAttributeCallback callback + ) { readInt40uAttribute(chipClusterPtr, callback); } - public void writeInt40uAttribute(DefaultClusterCallback callback, Long value) { writeInt40uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt40uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt40uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt48uAttribute(LongAttributeCallback callback) { + public void readInt48uAttribute( + LongAttributeCallback callback + ) { readInt48uAttribute(chipClusterPtr, callback); } - public void writeInt48uAttribute(DefaultClusterCallback callback, Long value) { writeInt48uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt48uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt48uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt56uAttribute(LongAttributeCallback callback) { + public void readInt56uAttribute( + LongAttributeCallback callback + ) { readInt56uAttribute(chipClusterPtr, callback); } - public void writeInt56uAttribute(DefaultClusterCallback callback, Long value) { writeInt56uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt56uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt56uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt64uAttribute(LongAttributeCallback callback) { + public void readInt64uAttribute( + LongAttributeCallback callback + ) { readInt64uAttribute(chipClusterPtr, callback); } - public void writeInt64uAttribute(DefaultClusterCallback callback, Long value) { writeInt64uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt64uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt64uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt8sAttribute(IntegerAttributeCallback callback) { + public void readInt8sAttribute( + IntegerAttributeCallback callback + ) { readInt8sAttribute(chipClusterPtr, callback); } - public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt8sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt8sAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt16sAttribute(IntegerAttributeCallback callback) { + public void readInt16sAttribute( + IntegerAttributeCallback callback + ) { readInt16sAttribute(chipClusterPtr, callback); } - public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt16sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt16sAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt24sAttribute(LongAttributeCallback callback) { + public void readInt24sAttribute( + LongAttributeCallback callback + ) { readInt24sAttribute(chipClusterPtr, callback); } - public void writeInt24sAttribute(DefaultClusterCallback callback, Long value) { writeInt24sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt24sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt24sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt32sAttribute(LongAttributeCallback callback) { + public void readInt32sAttribute( + LongAttributeCallback callback + ) { readInt32sAttribute(chipClusterPtr, callback); } - public void writeInt32sAttribute(DefaultClusterCallback callback, Long value) { writeInt32sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt32sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt32sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt40sAttribute(LongAttributeCallback callback) { + public void readInt40sAttribute( + LongAttributeCallback callback + ) { readInt40sAttribute(chipClusterPtr, callback); } - public void writeInt40sAttribute(DefaultClusterCallback callback, Long value) { writeInt40sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt40sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt40sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt48sAttribute(LongAttributeCallback callback) { + public void readInt48sAttribute( + LongAttributeCallback callback + ) { readInt48sAttribute(chipClusterPtr, callback); } - public void writeInt48sAttribute(DefaultClusterCallback callback, Long value) { writeInt48sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt48sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt48sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt56sAttribute(LongAttributeCallback callback) { + public void readInt56sAttribute( + LongAttributeCallback callback + ) { readInt56sAttribute(chipClusterPtr, callback); } - public void writeInt56sAttribute(DefaultClusterCallback callback, Long value) { writeInt56sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt56sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt56sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt64sAttribute(LongAttributeCallback callback) { + public void readInt64sAttribute( + LongAttributeCallback callback + ) { readInt64sAttribute(chipClusterPtr, callback); } - public void writeInt64sAttribute(DefaultClusterCallback callback, Long value) { writeInt64sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt64sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt64sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnum8Attribute(IntegerAttributeCallback callback) { + public void readEnum8Attribute( + IntegerAttributeCallback callback + ) { readEnum8Attribute(chipClusterPtr, callback); } - public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value) { writeEnum8Attribute(chipClusterPtr, callback, value, null); } - public void writeEnum8Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEnum8Attribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnum16Attribute(IntegerAttributeCallback callback) { + public void readEnum16Attribute( + IntegerAttributeCallback callback + ) { readEnum16Attribute(chipClusterPtr, callback); } - public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value) { writeEnum16Attribute(chipClusterPtr, callback, value, null); } - public void writeEnum16Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEnum16Attribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFloatSingleAttribute(FloatAttributeCallback callback) { + public void readFloatSingleAttribute( + FloatAttributeCallback callback + ) { readFloatSingleAttribute(chipClusterPtr, callback); } - public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value) { writeFloatSingleAttribute(chipClusterPtr, callback, value, null); } - public void writeFloatSingleAttribute( - DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { writeFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeFloatSingleAttribute( - FloatAttributeCallback callback, int minInterval, int maxInterval) { + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFloatDoubleAttribute(DoubleAttributeCallback callback) { + public void readFloatDoubleAttribute( + DoubleAttributeCallback callback + ) { readFloatDoubleAttribute(chipClusterPtr, callback); } - public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { writeFloatDoubleAttribute(chipClusterPtr, callback, value, null); } - public void writeFloatDoubleAttribute( - DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { writeFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeFloatDoubleAttribute( - DoubleAttributeCallback callback, int minInterval, int maxInterval) { + DoubleAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOctetStringAttribute(OctetStringAttributeCallback callback) { + public void readOctetStringAttribute( + OctetStringAttributeCallback callback + ) { readOctetStringAttribute(chipClusterPtr, callback); } - public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeOctetStringAttribute( - DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOctetStringAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListInt8uAttribute(ListInt8uAttributeCallback callback) { + public void readListInt8uAttribute( + ListInt8uAttributeCallback callback + ) { readListInt8uAttribute(chipClusterPtr, callback); } - public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value) { writeListInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeListInt8uAttribute( - DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeListInt8uAttribute( - ListInt8uAttributeCallback callback, int minInterval, int maxInterval) { + ListInt8uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeListInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListOctetStringAttribute(ListOctetStringAttributeCallback callback) { + public void readListOctetStringAttribute( + ListOctetStringAttributeCallback callback + ) { readListOctetStringAttribute(chipClusterPtr, callback); } - - public void writeListOctetStringAttribute( - DefaultClusterCallback callback, ArrayList value) { + public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { writeListOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeListOctetStringAttribute( - DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeListOctetStringAttribute( - ListOctetStringAttributeCallback callback, int minInterval, int maxInterval) { + ListOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeListOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readListStructOctetStringAttribute( - ListStructOctetStringAttributeCallback callback) { + ListStructOctetStringAttributeCallback callback + ) { readListStructOctetStringAttribute(chipClusterPtr, callback); } - - public void writeListStructOctetStringAttribute( - DefaultClusterCallback callback, - ArrayList value) { + public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { writeListStructOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeListStructOctetStringAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { + public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListStructOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeListStructOctetStringAttribute( - ListStructOctetStringAttributeCallback callback, int minInterval, int maxInterval) { + ListStructOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeListStructOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLongOctetStringAttribute(OctetStringAttributeCallback callback) { + public void readLongOctetStringAttribute( + OctetStringAttributeCallback callback + ) { readLongOctetStringAttribute(chipClusterPtr, callback); } - public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeLongOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeLongOctetStringAttribute( - DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeLongOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLongOctetStringAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCharStringAttribute(CharStringAttributeCallback callback) { + public void readCharStringAttribute( + CharStringAttributeCallback callback + ) { readCharStringAttribute(chipClusterPtr, callback); } - public void writeCharStringAttribute(DefaultClusterCallback callback, String value) { writeCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeCharStringAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeCharStringAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLongCharStringAttribute(CharStringAttributeCallback callback) { + public void readLongCharStringAttribute( + CharStringAttributeCallback callback + ) { readLongCharStringAttribute(chipClusterPtr, callback); } - public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value) { writeLongCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeLongCharStringAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLongCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLongCharStringAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLongCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEpochUsAttribute(LongAttributeCallback callback) { + public void readEpochUsAttribute( + LongAttributeCallback callback + ) { readEpochUsAttribute(chipClusterPtr, callback); } - public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value) { writeEpochUsAttribute(chipClusterPtr, callback, value, null); } - public void writeEpochUsAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeEpochUsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEpochUsAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEpochUsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEpochSAttribute(LongAttributeCallback callback) { + public void readEpochSAttribute( + LongAttributeCallback callback + ) { readEpochSAttribute(chipClusterPtr, callback); } - public void writeEpochSAttribute(DefaultClusterCallback callback, Long value) { writeEpochSAttribute(chipClusterPtr, callback, value, null); } - public void writeEpochSAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeEpochSAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeEpochSAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEpochSAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEpochSAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIdAttribute(VendorIdAttributeCallback callback) { + public void readVendorIdAttribute( + VendorIdAttributeCallback callback + ) { readVendorIdAttribute(chipClusterPtr, callback); } - public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value) { writeVendorIdAttribute(chipClusterPtr, callback, value, null); } - public void writeVendorIdAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeVendorIdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeVendorIdAttribute( - VendorIdAttributeCallback callback, int minInterval, int maxInterval) { + VendorIdAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readListNullablesAndOptionalsStructAttribute( - ListNullablesAndOptionalsStructAttributeCallback callback) { + ListNullablesAndOptionalsStructAttributeCallback callback + ) { readListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback); } - - public void writeListNullablesAndOptionalsStructAttribute( - DefaultClusterCallback callback, - ArrayList value) { + public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value) { writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, null); } - public void writeListNullablesAndOptionalsStructAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { - writeListNullablesAndOptionalsStructAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeListNullablesAndOptionalsStructAttribute( - ListNullablesAndOptionalsStructAttributeCallback callback, - int minInterval, - int maxInterval) { - subscribeListNullablesAndOptionalsStructAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + ListNullablesAndOptionalsStructAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnumAttrAttribute(IntegerAttributeCallback callback) { + public void readEnumAttrAttribute( + IntegerAttributeCallback callback + ) { readEnumAttrAttribute(chipClusterPtr, callback); } - public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { writeEnumAttrAttribute(chipClusterPtr, callback, value, null); } - public void writeEnumAttrAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEnumAttrAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt8uAttribute(IntegerAttributeCallback callback) { + public void readRangeRestrictedInt8uAttribute( + IntegerAttributeCallback callback + ) { readRangeRestrictedInt8uAttribute(chipClusterPtr, callback); } - public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt8uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeRangeRestrictedInt8uAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt8sAttribute(IntegerAttributeCallback callback) { + public void readRangeRestrictedInt8sAttribute( + IntegerAttributeCallback callback + ) { readRangeRestrictedInt8sAttribute(chipClusterPtr, callback); } - public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt8sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeRangeRestrictedInt8sAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt16uAttribute(IntegerAttributeCallback callback) { + public void readRangeRestrictedInt16uAttribute( + IntegerAttributeCallback callback + ) { readRangeRestrictedInt16uAttribute(chipClusterPtr, callback); } - - public void writeRangeRestrictedInt16uAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt16uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeRangeRestrictedInt16uAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt16sAttribute(IntegerAttributeCallback callback) { + public void readRangeRestrictedInt16sAttribute( + IntegerAttributeCallback callback + ) { readRangeRestrictedInt16sAttribute(chipClusterPtr, callback); } - - public void writeRangeRestrictedInt16sAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt16sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeRangeRestrictedInt16sAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListLongOctetStringAttribute(ListLongOctetStringAttributeCallback callback) { + public void readListLongOctetStringAttribute( + ListLongOctetStringAttributeCallback callback + ) { readListLongOctetStringAttribute(chipClusterPtr, callback); } - public void subscribeListLongOctetStringAttribute( - ListLongOctetStringAttributeCallback callback, int minInterval, int maxInterval) { + ListLongOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeListLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTimedWriteBooleanAttribute(BooleanAttributeCallback callback) { + public void readTimedWriteBooleanAttribute( + BooleanAttributeCallback callback + ) { readTimedWriteBooleanAttribute(chipClusterPtr, callback); } - public void writeTimedWriteBooleanAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeTimedWriteBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeTimedWriteBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeTimedWriteBooleanAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTimedWriteBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGeneralErrorBooleanAttribute(BooleanAttributeCallback callback) { + public void readGeneralErrorBooleanAttribute( + BooleanAttributeCallback callback + ) { readGeneralErrorBooleanAttribute(chipClusterPtr, callback); } - public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeGeneralErrorBooleanAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeGeneralErrorBooleanAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeGeneralErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterErrorBooleanAttribute(BooleanAttributeCallback callback) { + public void readClusterErrorBooleanAttribute( + BooleanAttributeCallback callback + ) { readClusterErrorBooleanAttribute(chipClusterPtr, callback); } - public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeClusterErrorBooleanAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeClusterErrorBooleanAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUnsupportedAttribute(BooleanAttributeCallback callback) { + public void readUnsupportedAttribute( + BooleanAttributeCallback callback + ) { readUnsupportedAttribute(chipClusterPtr, callback); } - public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value) { writeUnsupportedAttribute(chipClusterPtr, callback, value, null); } - public void writeUnsupportedAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeUnsupportedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeUnsupportedAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeUnsupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBooleanAttribute(NullableBooleanAttributeCallback callback) { + public void readNullableBooleanAttribute( + NullableBooleanAttributeCallback callback + ) { readNullableBooleanAttribute(chipClusterPtr, callback); } - public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeNullableBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableBooleanAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeNullableBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableBooleanAttribute( - NullableBooleanAttributeCallback callback, int minInterval, int maxInterval) { + NullableBooleanAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap8Attribute(NullableBitmap8AttributeCallback callback) { + public void readNullableBitmap8Attribute( + NullableBitmap8AttributeCallback callback + ) { readNullableBitmap8Attribute(chipClusterPtr, callback); } - public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value) { writeNullableBitmap8Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap8Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableBitmap8Attribute( - NullableBitmap8AttributeCallback callback, int minInterval, int maxInterval) { + NullableBitmap8AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap16Attribute(NullableBitmap16AttributeCallback callback) { + public void readNullableBitmap16Attribute( + NullableBitmap16AttributeCallback callback + ) { readNullableBitmap16Attribute(chipClusterPtr, callback); } - public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value) { writeNullableBitmap16Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap16Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableBitmap16Attribute( - NullableBitmap16AttributeCallback callback, int minInterval, int maxInterval) { + NullableBitmap16AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap32Attribute(NullableBitmap32AttributeCallback callback) { + public void readNullableBitmap32Attribute( + NullableBitmap32AttributeCallback callback + ) { readNullableBitmap32Attribute(chipClusterPtr, callback); } - public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value) { writeNullableBitmap32Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap32Attribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableBitmap32Attribute( - NullableBitmap32AttributeCallback callback, int minInterval, int maxInterval) { + NullableBitmap32AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap64Attribute(NullableBitmap64AttributeCallback callback) { + public void readNullableBitmap64Attribute( + NullableBitmap64AttributeCallback callback + ) { readNullableBitmap64Attribute(chipClusterPtr, callback); } - public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value) { writeNullableBitmap64Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap64Attribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableBitmap64Attribute( - NullableBitmap64AttributeCallback callback, int minInterval, int maxInterval) { + NullableBitmap64AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt8uAttribute(NullableInt8uAttributeCallback callback) { + public void readNullableInt8uAttribute( + NullableInt8uAttributeCallback callback + ) { readNullableInt8uAttribute(chipClusterPtr, callback); } - public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt8uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt8uAttribute( - NullableInt8uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt8uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt16uAttribute(NullableInt16uAttributeCallback callback) { + public void readNullableInt16uAttribute( + NullableInt16uAttributeCallback callback + ) { readNullableInt16uAttribute(chipClusterPtr, callback); } - public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt16uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt16uAttribute( - NullableInt16uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt16uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt24uAttribute(NullableInt24uAttributeCallback callback) { + public void readNullableInt24uAttribute( + NullableInt24uAttributeCallback callback + ) { readNullableInt24uAttribute(chipClusterPtr, callback); } - public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt24uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt24uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt24uAttribute( - NullableInt24uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt24uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt32uAttribute(NullableInt32uAttributeCallback callback) { + public void readNullableInt32uAttribute( + NullableInt32uAttributeCallback callback + ) { readNullableInt32uAttribute(chipClusterPtr, callback); } - public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt32uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt32uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt32uAttribute( - NullableInt32uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt32uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt40uAttribute(NullableInt40uAttributeCallback callback) { + public void readNullableInt40uAttribute( + NullableInt40uAttributeCallback callback + ) { readNullableInt40uAttribute(chipClusterPtr, callback); } - public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt40uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt40uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt40uAttribute( - NullableInt40uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt40uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt48uAttribute(NullableInt48uAttributeCallback callback) { + public void readNullableInt48uAttribute( + NullableInt48uAttributeCallback callback + ) { readNullableInt48uAttribute(chipClusterPtr, callback); } - public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt48uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt48uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt48uAttribute( - NullableInt48uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt48uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt56uAttribute(NullableInt56uAttributeCallback callback) { + public void readNullableInt56uAttribute( + NullableInt56uAttributeCallback callback + ) { readNullableInt56uAttribute(chipClusterPtr, callback); } - public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt56uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt56uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt56uAttribute( - NullableInt56uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt56uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt64uAttribute(NullableInt64uAttributeCallback callback) { + public void readNullableInt64uAttribute( + NullableInt64uAttributeCallback callback + ) { readNullableInt64uAttribute(chipClusterPtr, callback); } - public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt64uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt64uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt64uAttribute( - NullableInt64uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt64uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt8sAttribute(NullableInt8sAttributeCallback callback) { + public void readNullableInt8sAttribute( + NullableInt8sAttributeCallback callback + ) { readNullableInt8sAttribute(chipClusterPtr, callback); } - public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt8sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt8sAttribute( - NullableInt8sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt8sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt16sAttribute(NullableInt16sAttributeCallback callback) { + public void readNullableInt16sAttribute( + NullableInt16sAttributeCallback callback + ) { readNullableInt16sAttribute(chipClusterPtr, callback); } - public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt16sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt16sAttribute( - NullableInt16sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt16sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt24sAttribute(NullableInt24sAttributeCallback callback) { + public void readNullableInt24sAttribute( + NullableInt24sAttributeCallback callback + ) { readNullableInt24sAttribute(chipClusterPtr, callback); } - public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt24sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt24sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt24sAttribute( - NullableInt24sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt24sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt32sAttribute(NullableInt32sAttributeCallback callback) { + public void readNullableInt32sAttribute( + NullableInt32sAttributeCallback callback + ) { readNullableInt32sAttribute(chipClusterPtr, callback); } - public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt32sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt32sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt32sAttribute( - NullableInt32sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt32sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt40sAttribute(NullableInt40sAttributeCallback callback) { + public void readNullableInt40sAttribute( + NullableInt40sAttributeCallback callback + ) { readNullableInt40sAttribute(chipClusterPtr, callback); } - public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt40sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt40sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt40sAttribute( - NullableInt40sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt40sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt48sAttribute(NullableInt48sAttributeCallback callback) { + public void readNullableInt48sAttribute( + NullableInt48sAttributeCallback callback + ) { readNullableInt48sAttribute(chipClusterPtr, callback); } - public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt48sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt48sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt48sAttribute( - NullableInt48sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt48sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt56sAttribute(NullableInt56sAttributeCallback callback) { + public void readNullableInt56sAttribute( + NullableInt56sAttributeCallback callback + ) { readNullableInt56sAttribute(chipClusterPtr, callback); } - public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt56sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt56sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt56sAttribute( - NullableInt56sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt56sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt64sAttribute(NullableInt64sAttributeCallback callback) { + public void readNullableInt64sAttribute( + NullableInt64sAttributeCallback callback + ) { readNullableInt64sAttribute(chipClusterPtr, callback); } - public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt64sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt64sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt64sAttribute( - NullableInt64sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt64sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnum8Attribute(NullableEnum8AttributeCallback callback) { + public void readNullableEnum8Attribute( + NullableEnum8AttributeCallback callback + ) { readNullableEnum8Attribute(chipClusterPtr, callback); } - public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value) { writeNullableEnum8Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnum8Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableEnum8Attribute( - NullableEnum8AttributeCallback callback, int minInterval, int maxInterval) { + NullableEnum8AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnum16Attribute(NullableEnum16AttributeCallback callback) { + public void readNullableEnum16Attribute( + NullableEnum16AttributeCallback callback + ) { readNullableEnum16Attribute(chipClusterPtr, callback); } - public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value) { writeNullableEnum16Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnum16Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableEnum16Attribute( - NullableEnum16AttributeCallback callback, int minInterval, int maxInterval) { + NullableEnum16AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableFloatSingleAttribute(NullableFloatSingleAttributeCallback callback) { + public void readNullableFloatSingleAttribute( + NullableFloatSingleAttributeCallback callback + ) { readNullableFloatSingleAttribute(chipClusterPtr, callback); } - public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value) { writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableFloatSingleAttribute( - DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableFloatSingleAttribute( - NullableFloatSingleAttributeCallback callback, int minInterval, int maxInterval) { + NullableFloatSingleAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableFloatDoubleAttribute(NullableFloatDoubleAttributeCallback callback) { + public void readNullableFloatDoubleAttribute( + NullableFloatDoubleAttributeCallback callback + ) { readNullableFloatDoubleAttribute(chipClusterPtr, callback); } - public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableFloatDoubleAttribute( - DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableFloatDoubleAttribute( - NullableFloatDoubleAttributeCallback callback, int minInterval, int maxInterval) { + NullableFloatDoubleAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableOctetStringAttribute(NullableOctetStringAttributeCallback callback) { + public void readNullableOctetStringAttribute( + NullableOctetStringAttributeCallback callback + ) { readNullableOctetStringAttribute(chipClusterPtr, callback); } - public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeNullableOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableOctetStringAttribute( - DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeNullableOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableOctetStringAttribute( - NullableOctetStringAttributeCallback callback, int minInterval, int maxInterval) { + NullableOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableCharStringAttribute(NullableCharStringAttributeCallback callback) { + public void readNullableCharStringAttribute( + NullableCharStringAttributeCallback callback + ) { readNullableCharStringAttribute(chipClusterPtr, callback); } - public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value) { writeNullableCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableCharStringAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeNullableCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableCharStringAttribute( - NullableCharStringAttributeCallback callback, int minInterval, int maxInterval) { + NullableCharStringAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnumAttrAttribute(NullableEnumAttrAttributeCallback callback) { + public void readNullableEnumAttrAttribute( + NullableEnumAttrAttributeCallback callback + ) { readNullableEnumAttrAttribute(chipClusterPtr, callback); } - public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnumAttrAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableEnumAttrAttribute( - NullableEnumAttrAttributeCallback callback, int minInterval, int maxInterval) { + NullableEnumAttrAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt8uAttribute( - NullableRangeRestrictedInt8uAttributeCallback callback) { + NullableRangeRestrictedInt8uAttributeCallback callback + ) { readNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback); } - - public void writeNullableRangeRestrictedInt8uAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt8uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt8uAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableRangeRestrictedInt8uAttribute( - NullableRangeRestrictedInt8uAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt8uAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt8uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt8sAttribute( - NullableRangeRestrictedInt8sAttributeCallback callback) { + NullableRangeRestrictedInt8sAttributeCallback callback + ) { readNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback); } - - public void writeNullableRangeRestrictedInt8sAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt8sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt8sAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableRangeRestrictedInt8sAttribute( - NullableRangeRestrictedInt8sAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt8sAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt8sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt16uAttribute( - NullableRangeRestrictedInt16uAttributeCallback callback) { + NullableRangeRestrictedInt16uAttributeCallback callback + ) { readNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback); } - - public void writeNullableRangeRestrictedInt16uAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt16uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt16uAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableRangeRestrictedInt16uAttribute( - NullableRangeRestrictedInt16uAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt16uAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt16uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt16sAttribute( - NullableRangeRestrictedInt16sAttributeCallback callback) { + NullableRangeRestrictedInt16sAttributeCallback callback + ) { readNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback); } - - public void writeNullableRangeRestrictedInt16sAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt16sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt16sAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableRangeRestrictedInt16sAttribute( - NullableRangeRestrictedInt16sAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt16sAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt16sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeBooleanAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBitmap8Attribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeBitmap8Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBitmap8Attribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBitmap16Attribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeBitmap16Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBitmap16Attribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBitmap32Attribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeBitmap32Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBitmap32Attribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBitmap64Attribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeBitmap64Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBitmap64Attribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt8uAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeInt8uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt8uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt16uAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeInt16uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt16uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt24uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt24uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt24uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt32uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt32uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt32uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt40uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt40uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt40uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt48uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt48uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt48uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt56uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt56uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt56uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt64uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt64uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt64uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt8sAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeInt8sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt8sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt16sAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeInt16sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt16sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt24sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt24sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt24sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt32sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt32sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt32sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt40sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt40sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt40sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt48sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt48sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt48sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt56sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt56sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt56sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt64sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt64sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt64sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnum8Attribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeEnum8Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEnum8Attribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnum16Attribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeEnum16Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEnum16Attribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readFloatSingleAttribute( - long chipClusterPtr, FloatAttributeCallback callback); - - private native void writeFloatSingleAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Float value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeFloatSingleAttribute( - long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval); - - private native void readFloatDoubleAttribute( - long chipClusterPtr, DoubleAttributeCallback callback); - - private native void writeFloatDoubleAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Double value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeFloatDoubleAttribute( - long chipClusterPtr, DoubleAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOctetStringAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void writeOctetStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - byte[] value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOctetStringAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readListInt8uAttribute( - long chipClusterPtr, ListInt8uAttributeCallback callback); - - private native void writeListInt8uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeListInt8uAttribute( - long chipClusterPtr, ListInt8uAttributeCallback callback, int minInterval, int maxInterval); - - private native void readListOctetStringAttribute( - long chipClusterPtr, ListOctetStringAttributeCallback callback); - - private native void writeListOctetStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeListOctetStringAttribute( - long chipClusterPtr, - ListOctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readListStructOctetStringAttribute( - long chipClusterPtr, ListStructOctetStringAttributeCallback callback); - - private native void writeListStructOctetStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeListStructOctetStringAttribute( - long chipClusterPtr, - ListStructOctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readLongOctetStringAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void writeLongOctetStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - byte[] value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLongOctetStringAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCharStringAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeCharStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeCharStringAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readLongCharStringAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeLongCharStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLongCharStringAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readEpochUsAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeEpochUsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEpochUsAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEpochSAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeEpochSAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEpochSAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readVendorIdAttribute( - long chipClusterPtr, VendorIdAttributeCallback callback); - - private native void writeVendorIdAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeVendorIdAttribute( - long chipClusterPtr, VendorIdAttributeCallback callback, int minInterval, int maxInterval); - - private native void readListNullablesAndOptionalsStructAttribute( - long chipClusterPtr, ListNullablesAndOptionalsStructAttributeCallback callback); - - private native void writeListNullablesAndOptionalsStructAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeListNullablesAndOptionalsStructAttribute( - long chipClusterPtr, - ListNullablesAndOptionalsStructAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readEnumAttrAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeEnumAttrAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEnumAttrAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt8uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeRangeRestrictedInt8uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeRangeRestrictedInt8uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt8sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeRangeRestrictedInt8sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeRangeRestrictedInt8sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt16uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeRangeRestrictedInt16uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeRangeRestrictedInt16uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt16sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeRangeRestrictedInt16sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeRangeRestrictedInt16sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readListLongOctetStringAttribute( - long chipClusterPtr, ListLongOctetStringAttributeCallback callback); - - private native void subscribeListLongOctetStringAttribute( - long chipClusterPtr, - ListLongOctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readTimedWriteBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeTimedWriteBooleanAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeTimedWriteBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readGeneralErrorBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeGeneralErrorBooleanAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeGeneralErrorBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readClusterErrorBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeClusterErrorBooleanAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeClusterErrorBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readUnsupportedAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeUnsupportedAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeUnsupportedAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNullableBooleanAttribute( - long chipClusterPtr, NullableBooleanAttributeCallback callback); - - private native void writeNullableBooleanAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableBooleanAttribute( - long chipClusterPtr, - NullableBooleanAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableBitmap8Attribute( - long chipClusterPtr, NullableBitmap8AttributeCallback callback); - - private native void writeNullableBitmap8Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableBitmap8Attribute( - long chipClusterPtr, - NullableBitmap8AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableBitmap16Attribute( - long chipClusterPtr, NullableBitmap16AttributeCallback callback); - - private native void writeNullableBitmap16Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableBitmap16Attribute( - long chipClusterPtr, - NullableBitmap16AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableBitmap32Attribute( - long chipClusterPtr, NullableBitmap32AttributeCallback callback); - - private native void writeNullableBitmap32Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableBitmap32Attribute( - long chipClusterPtr, - NullableBitmap32AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableBitmap64Attribute( - long chipClusterPtr, NullableBitmap64AttributeCallback callback); - - private native void writeNullableBitmap64Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableBitmap64Attribute( - long chipClusterPtr, - NullableBitmap64AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt8uAttribute( - long chipClusterPtr, NullableInt8uAttributeCallback callback); - - private native void writeNullableInt8uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt8uAttribute( - long chipClusterPtr, - NullableInt8uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt16uAttribute( - long chipClusterPtr, NullableInt16uAttributeCallback callback); - - private native void writeNullableInt16uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt16uAttribute( - long chipClusterPtr, - NullableInt16uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt24uAttribute( - long chipClusterPtr, NullableInt24uAttributeCallback callback); - - private native void writeNullableInt24uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt24uAttribute( - long chipClusterPtr, - NullableInt24uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt32uAttribute( - long chipClusterPtr, NullableInt32uAttributeCallback callback); - - private native void writeNullableInt32uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt32uAttribute( - long chipClusterPtr, - NullableInt32uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt40uAttribute( - long chipClusterPtr, NullableInt40uAttributeCallback callback); - - private native void writeNullableInt40uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt40uAttribute( - long chipClusterPtr, - NullableInt40uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt48uAttribute( - long chipClusterPtr, NullableInt48uAttributeCallback callback); - - private native void writeNullableInt48uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt48uAttribute( - long chipClusterPtr, - NullableInt48uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt56uAttribute( - long chipClusterPtr, NullableInt56uAttributeCallback callback); - - private native void writeNullableInt56uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt56uAttribute( - long chipClusterPtr, - NullableInt56uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt64uAttribute( - long chipClusterPtr, NullableInt64uAttributeCallback callback); - - private native void writeNullableInt64uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt64uAttribute( - long chipClusterPtr, - NullableInt64uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt8sAttribute( - long chipClusterPtr, NullableInt8sAttributeCallback callback); - - private native void writeNullableInt8sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt8sAttribute( - long chipClusterPtr, - NullableInt8sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt16sAttribute( - long chipClusterPtr, NullableInt16sAttributeCallback callback); - - private native void writeNullableInt16sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt16sAttribute( - long chipClusterPtr, - NullableInt16sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt24sAttribute( - long chipClusterPtr, NullableInt24sAttributeCallback callback); - - private native void writeNullableInt24sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt24sAttribute( - long chipClusterPtr, - NullableInt24sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt32sAttribute( - long chipClusterPtr, NullableInt32sAttributeCallback callback); - - private native void writeNullableInt32sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt32sAttribute( - long chipClusterPtr, - NullableInt32sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt40sAttribute( - long chipClusterPtr, NullableInt40sAttributeCallback callback); - - private native void writeNullableInt40sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt40sAttribute( - long chipClusterPtr, - NullableInt40sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt48sAttribute( - long chipClusterPtr, NullableInt48sAttributeCallback callback); - - private native void writeNullableInt48sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt48sAttribute( - long chipClusterPtr, - NullableInt48sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt56sAttribute( - long chipClusterPtr, NullableInt56sAttributeCallback callback); - - private native void writeNullableInt56sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt56sAttribute( - long chipClusterPtr, - NullableInt56sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt64sAttribute( - long chipClusterPtr, NullableInt64sAttributeCallback callback); - - private native void writeNullableInt64sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt64sAttribute( - long chipClusterPtr, - NullableInt64sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableEnum8Attribute( - long chipClusterPtr, NullableEnum8AttributeCallback callback); - - private native void writeNullableEnum8Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableEnum8Attribute( - long chipClusterPtr, - NullableEnum8AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableEnum16Attribute( - long chipClusterPtr, NullableEnum16AttributeCallback callback); - - private native void writeNullableEnum16Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableEnum16Attribute( - long chipClusterPtr, - NullableEnum16AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableFloatSingleAttribute( - long chipClusterPtr, NullableFloatSingleAttributeCallback callback); - - private native void writeNullableFloatSingleAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Float value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableFloatSingleAttribute( - long chipClusterPtr, - NullableFloatSingleAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableFloatDoubleAttribute( - long chipClusterPtr, NullableFloatDoubleAttributeCallback callback); - - private native void writeNullableFloatDoubleAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Double value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableFloatDoubleAttribute( - long chipClusterPtr, - NullableFloatDoubleAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableOctetStringAttribute( - long chipClusterPtr, NullableOctetStringAttributeCallback callback); - - private native void writeNullableOctetStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - byte[] value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableOctetStringAttribute( - long chipClusterPtr, - NullableOctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableCharStringAttribute( - long chipClusterPtr, NullableCharStringAttributeCallback callback); - - private native void writeNullableCharStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableCharStringAttribute( - long chipClusterPtr, - NullableCharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableEnumAttrAttribute( - long chipClusterPtr, NullableEnumAttrAttributeCallback callback); - - private native void writeNullableEnumAttrAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableEnumAttrAttribute( - long chipClusterPtr, - NullableEnumAttrAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableRangeRestrictedInt8uAttribute( - long chipClusterPtr, NullableRangeRestrictedInt8uAttributeCallback callback); - - private native void writeNullableRangeRestrictedInt8uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableRangeRestrictedInt8uAttribute( - long chipClusterPtr, - NullableRangeRestrictedInt8uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableRangeRestrictedInt8sAttribute( - long chipClusterPtr, NullableRangeRestrictedInt8sAttributeCallback callback); - - private native void writeNullableRangeRestrictedInt8sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableRangeRestrictedInt8sAttribute( - long chipClusterPtr, - NullableRangeRestrictedInt8sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableRangeRestrictedInt16uAttribute( - long chipClusterPtr, NullableRangeRestrictedInt16uAttributeCallback callback); - - private native void writeNullableRangeRestrictedInt16uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableRangeRestrictedInt16uAttribute( - long chipClusterPtr, - NullableRangeRestrictedInt16uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableRangeRestrictedInt16sAttribute( - long chipClusterPtr, NullableRangeRestrictedInt16sAttributeCallback callback); - - private native void writeNullableRangeRestrictedInt16sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableRangeRestrictedInt16sAttribute( - long chipClusterPtr, - NullableRangeRestrictedInt16sAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap32Attribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap32Attribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap64Attribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap64Attribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt24uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt24uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt32uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt32uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt40uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt40uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt48uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt48uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt56uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt56uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt64uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt64uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt24sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt24sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt32sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt32sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt40sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt40sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt48sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt48sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt56sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt56sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt64sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt64sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnum8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnum8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnum16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnum16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readFloatSingleAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + + private native void writeFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeFloatSingleAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readFloatDoubleAttribute(long chipClusterPtr, + DoubleAttributeCallback callback + ); + + private native void writeFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeFloatDoubleAttribute(long chipClusterPtr, + DoubleAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + + private native void writeOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readListInt8uAttribute(long chipClusterPtr, + ListInt8uAttributeCallback callback + ); + + private native void writeListInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListInt8uAttribute(long chipClusterPtr, + ListInt8uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readListOctetStringAttribute(long chipClusterPtr, + ListOctetStringAttributeCallback callback + ); + + private native void writeListOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListOctetStringAttribute(long chipClusterPtr, + ListOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readListStructOctetStringAttribute(long chipClusterPtr, + ListStructOctetStringAttributeCallback callback + ); + + private native void writeListStructOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListStructOctetStringAttribute(long chipClusterPtr, + ListStructOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLongOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + + private native void writeLongOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLongOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLongCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeLongCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLongCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEpochUsAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeEpochUsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEpochUsAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEpochSAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeEpochSAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEpochSAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorIdAttribute(long chipClusterPtr, + VendorIdAttributeCallback callback + ); + + private native void writeVendorIdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeVendorIdAttribute(long chipClusterPtr, + VendorIdAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readListNullablesAndOptionalsStructAttribute(long chipClusterPtr, + ListNullablesAndOptionalsStructAttributeCallback callback + ); + + private native void writeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, + ListNullablesAndOptionalsStructAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEnumAttrAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnumAttrAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readListLongOctetStringAttribute(long chipClusterPtr, + ListLongOctetStringAttributeCallback callback + ); + private native void subscribeListLongOctetStringAttribute(long chipClusterPtr, + ListLongOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTimedWriteBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeTimedWriteBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeTimedWriteBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneralErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeGeneralErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeGeneralErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeClusterErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeClusterErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUnsupportedAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeUnsupportedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeUnsupportedAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNullableBooleanAttribute(long chipClusterPtr, + NullableBooleanAttributeCallback callback + ); + + private native void writeNullableBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBooleanAttribute(long chipClusterPtr, + NullableBooleanAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap8Attribute(long chipClusterPtr, + NullableBitmap8AttributeCallback callback + ); + + private native void writeNullableBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap8Attribute(long chipClusterPtr, + NullableBitmap8AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap16Attribute(long chipClusterPtr, + NullableBitmap16AttributeCallback callback + ); + + private native void writeNullableBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap16Attribute(long chipClusterPtr, + NullableBitmap16AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap32Attribute(long chipClusterPtr, + NullableBitmap32AttributeCallback callback + ); + + private native void writeNullableBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap32Attribute(long chipClusterPtr, + NullableBitmap32AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap64Attribute(long chipClusterPtr, + NullableBitmap64AttributeCallback callback + ); + + private native void writeNullableBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap64Attribute(long chipClusterPtr, + NullableBitmap64AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt8uAttribute(long chipClusterPtr, + NullableInt8uAttributeCallback callback + ); + + private native void writeNullableInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt8uAttribute(long chipClusterPtr, + NullableInt8uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt16uAttribute(long chipClusterPtr, + NullableInt16uAttributeCallback callback + ); + + private native void writeNullableInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt16uAttribute(long chipClusterPtr, + NullableInt16uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt24uAttribute(long chipClusterPtr, + NullableInt24uAttributeCallback callback + ); + + private native void writeNullableInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt24uAttribute(long chipClusterPtr, + NullableInt24uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt32uAttribute(long chipClusterPtr, + NullableInt32uAttributeCallback callback + ); + + private native void writeNullableInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt32uAttribute(long chipClusterPtr, + NullableInt32uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt40uAttribute(long chipClusterPtr, + NullableInt40uAttributeCallback callback + ); + + private native void writeNullableInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt40uAttribute(long chipClusterPtr, + NullableInt40uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt48uAttribute(long chipClusterPtr, + NullableInt48uAttributeCallback callback + ); + + private native void writeNullableInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt48uAttribute(long chipClusterPtr, + NullableInt48uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt56uAttribute(long chipClusterPtr, + NullableInt56uAttributeCallback callback + ); + + private native void writeNullableInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt56uAttribute(long chipClusterPtr, + NullableInt56uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt64uAttribute(long chipClusterPtr, + NullableInt64uAttributeCallback callback + ); + + private native void writeNullableInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt64uAttribute(long chipClusterPtr, + NullableInt64uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt8sAttribute(long chipClusterPtr, + NullableInt8sAttributeCallback callback + ); + + private native void writeNullableInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt8sAttribute(long chipClusterPtr, + NullableInt8sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt16sAttribute(long chipClusterPtr, + NullableInt16sAttributeCallback callback + ); + + private native void writeNullableInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt16sAttribute(long chipClusterPtr, + NullableInt16sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt24sAttribute(long chipClusterPtr, + NullableInt24sAttributeCallback callback + ); + + private native void writeNullableInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt24sAttribute(long chipClusterPtr, + NullableInt24sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt32sAttribute(long chipClusterPtr, + NullableInt32sAttributeCallback callback + ); + + private native void writeNullableInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt32sAttribute(long chipClusterPtr, + NullableInt32sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt40sAttribute(long chipClusterPtr, + NullableInt40sAttributeCallback callback + ); + + private native void writeNullableInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt40sAttribute(long chipClusterPtr, + NullableInt40sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt48sAttribute(long chipClusterPtr, + NullableInt48sAttributeCallback callback + ); + + private native void writeNullableInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt48sAttribute(long chipClusterPtr, + NullableInt48sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt56sAttribute(long chipClusterPtr, + NullableInt56sAttributeCallback callback + ); + + private native void writeNullableInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt56sAttribute(long chipClusterPtr, + NullableInt56sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt64sAttribute(long chipClusterPtr, + NullableInt64sAttributeCallback callback + ); + + private native void writeNullableInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt64sAttribute(long chipClusterPtr, + NullableInt64sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableEnum8Attribute(long chipClusterPtr, + NullableEnum8AttributeCallback callback + ); + + private native void writeNullableEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableEnum8Attribute(long chipClusterPtr, + NullableEnum8AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableEnum16Attribute(long chipClusterPtr, + NullableEnum16AttributeCallback callback + ); + + private native void writeNullableEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableEnum16Attribute(long chipClusterPtr, + NullableEnum16AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableFloatSingleAttribute(long chipClusterPtr, + NullableFloatSingleAttributeCallback callback + ); + + private native void writeNullableFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableFloatSingleAttribute(long chipClusterPtr, + NullableFloatSingleAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableFloatDoubleAttribute(long chipClusterPtr, + NullableFloatDoubleAttributeCallback callback + ); + + private native void writeNullableFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableFloatDoubleAttribute(long chipClusterPtr, + NullableFloatDoubleAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableOctetStringAttribute(long chipClusterPtr, + NullableOctetStringAttributeCallback callback + ); + + private native void writeNullableOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableOctetStringAttribute(long chipClusterPtr, + NullableOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableCharStringAttribute(long chipClusterPtr, + NullableCharStringAttributeCallback callback + ); + + private native void writeNullableCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableCharStringAttribute(long chipClusterPtr, + NullableCharStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableEnumAttrAttribute(long chipClusterPtr, + NullableEnumAttrAttributeCallback callback + ); + + private native void writeNullableEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableEnumAttrAttribute(long chipClusterPtr, + NullableEnumAttrAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8uAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8sAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16uAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16sAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16sAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ThermostatCluster extends BaseChipCluster { @@ -15440,587 +14214,554 @@ public ThermostatCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void clearWeeklySchedule(DefaultClusterCallback callback) { + public void clearWeeklySchedule(DefaultClusterCallback callback + ) { clearWeeklySchedule(chipClusterPtr, callback, null); } - public void clearWeeklySchedule(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void clearWeeklySchedule(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { clearWeeklySchedule(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback) { + public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback + ) { getRelayStatusLog(chipClusterPtr, callback, null); } - public void getRelayStatusLog( - GetRelayStatusLogResponseCallback callback, int timedInvokeTimeoutMs) { - + public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback + + , int timedInvokeTimeoutMs) { getRelayStatusLog(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void getWeeklySchedule( - GetWeeklyScheduleResponseCallback callback, Integer daysToReturn, Integer modeToReturn) { + public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback + , Integer daysToReturn, Integer modeToReturn) { getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, null); } - public void getWeeklySchedule( - GetWeeklyScheduleResponseCallback callback, - Integer daysToReturn, - Integer modeToReturn, - int timedInvokeTimeoutMs) { + public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback + , Integer daysToReturn, Integer modeToReturn + , int timedInvokeTimeoutMs) { getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, timedInvokeTimeoutMs); } - public void setWeeklySchedule( - DefaultClusterCallback callback, - Integer numberOfTransitionsForSequence, - Integer dayOfWeekForSequence, - Integer modeForSequence, - ArrayList payload) { - setWeeklySchedule( - chipClusterPtr, - callback, - numberOfTransitionsForSequence, - dayOfWeekForSequence, - modeForSequence, - payload, - null); - } - - public void setWeeklySchedule( - DefaultClusterCallback callback, - Integer numberOfTransitionsForSequence, - Integer dayOfWeekForSequence, - Integer modeForSequence, - ArrayList payload, - int timedInvokeTimeoutMs) { - setWeeklySchedule( - chipClusterPtr, - callback, - numberOfTransitionsForSequence, - dayOfWeekForSequence, - modeForSequence, - payload, - timedInvokeTimeoutMs); - } - - public void setpointRaiseLower(DefaultClusterCallback callback, Integer mode, Integer amount) { - setpointRaiseLower(chipClusterPtr, callback, mode, amount, null); + public void setWeeklySchedule(DefaultClusterCallback callback + , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload) { + setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, payload, null); } - public void setpointRaiseLower( - DefaultClusterCallback callback, Integer mode, Integer amount, int timedInvokeTimeoutMs) { - setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs); + public void setWeeklySchedule(DefaultClusterCallback callback + , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload + , int timedInvokeTimeoutMs) { + setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, payload, timedInvokeTimeoutMs); } - private native void clearWeeklySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getRelayStatusLog( - long chipClusterPtr, - GetRelayStatusLogResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getWeeklySchedule( - long chipClusterPtr, - GetWeeklyScheduleResponseCallback Callback, - Integer daysToReturn, - Integer modeToReturn, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setWeeklySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer numberOfTransitionsForSequence, - Integer dayOfWeekForSequence, - Integer modeForSequence, - ArrayList payload, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setpointRaiseLower( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer mode, - Integer amount, - @Nullable Integer timedInvokeTimeoutMs); + public void setpointRaiseLower(DefaultClusterCallback callback + , Integer mode, Integer amount) { + setpointRaiseLower(chipClusterPtr, callback, mode, amount, null); + } + public void setpointRaiseLower(DefaultClusterCallback callback + , Integer mode, Integer amount + , int timedInvokeTimeoutMs) { + setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs); + } + private native void clearWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void getRelayStatusLog(long chipClusterPtr, GetRelayStatusLogResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void getWeeklySchedule(long chipClusterPtr, GetWeeklyScheduleResponseCallback Callback + , Integer daysToReturn, Integer modeToReturn + , @Nullable Integer timedInvokeTimeoutMs); + private native void setWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload + , @Nullable Integer timedInvokeTimeoutMs); + private native void setpointRaiseLower(long chipClusterPtr, DefaultClusterCallback Callback + , Integer mode, Integer amount + , @Nullable Integer timedInvokeTimeoutMs); public interface GetRelayStatusLogResponseCallback { - void onSuccess( - Integer timeOfDay, - Integer relayStatus, - Integer localTemperature, - Integer humidityInPercentage, - Integer setpoint, - Integer unreadEntries); - + void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries); + void onError(Exception error); } public interface GetWeeklyScheduleResponseCallback { - void onSuccess( - Integer numberOfTransitionsForSequence, - Integer dayOfWeekForSequence, - Integer modeForSequence, - ArrayList payload); - + void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload); + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readLocalTemperatureAttribute(IntegerAttributeCallback callback) { + public void readLocalTemperatureAttribute( + IntegerAttributeCallback callback + ) { readLocalTemperatureAttribute(chipClusterPtr, callback); } - public void subscribeLocalTemperatureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLocalTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMinHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readAbsMinHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback); } - public void subscribeAbsMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMaxHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readAbsMaxHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); } - public void subscribeAbsMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMinCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readAbsMinCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback); } - public void subscribeAbsMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMaxCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readAbsMaxCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); } - public void subscribeAbsMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupiedCoolingSetpointAttribute(IntegerAttributeCallback callback) { + public void readOccupiedCoolingSetpointAttribute( + IntegerAttributeCallback callback + ) { readOccupiedCoolingSetpointAttribute(chipClusterPtr, callback); } - - public void writeOccupiedCoolingSetpointAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value) { writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, null); } - public void writeOccupiedCoolingSetpointAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOccupiedCoolingSetpointAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupiedHeatingSetpointAttribute(IntegerAttributeCallback callback) { + public void readOccupiedHeatingSetpointAttribute( + IntegerAttributeCallback callback + ) { readOccupiedHeatingSetpointAttribute(chipClusterPtr, callback); } - - public void writeOccupiedHeatingSetpointAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value) { writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, null); } - public void writeOccupiedHeatingSetpointAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOccupiedHeatingSetpointAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readMinHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readMinHeatSetpointLimitAttribute(chipClusterPtr, callback); } - public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMinHeatSetpointLimitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readMaxHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); } - public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMaxHeatSetpointLimitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readMinCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readMinCoolSetpointLimitAttribute(chipClusterPtr, callback); } - public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMinCoolSetpointLimitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readMaxCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); } - public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMaxCoolSetpointLimitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinSetpointDeadBandAttribute(IntegerAttributeCallback callback) { + public void readMinSetpointDeadBandAttribute( + IntegerAttributeCallback callback + ) { readMinSetpointDeadBandAttribute(chipClusterPtr, callback); } - public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value) { writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, null); } - public void writeMinSetpointDeadBandAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeMinSetpointDeadBandAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinSetpointDeadBandAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readControlSequenceOfOperationAttribute(IntegerAttributeCallback callback) { + public void readControlSequenceOfOperationAttribute( + IntegerAttributeCallback callback + ) { readControlSequenceOfOperationAttribute(chipClusterPtr, callback); } - - public void writeControlSequenceOfOperationAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value) { writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, null); } - public void writeControlSequenceOfOperationAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeControlSequenceOfOperationAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeControlSequenceOfOperationAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeControlSequenceOfOperationAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeControlSequenceOfOperationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSystemModeAttribute(IntegerAttributeCallback callback) { + public void readSystemModeAttribute( + IntegerAttributeCallback callback + ) { readSystemModeAttribute(chipClusterPtr, callback); } - public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value) { writeSystemModeAttribute(chipClusterPtr, callback, value, null); } - public void writeSystemModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSystemModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeSystemModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSystemModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartOfWeekAttribute(IntegerAttributeCallback callback) { + public void readStartOfWeekAttribute( + IntegerAttributeCallback callback + ) { readStartOfWeekAttribute(chipClusterPtr, callback); } - public void subscribeStartOfWeekAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStartOfWeekAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfWeeklyTransitionsAttribute(IntegerAttributeCallback callback) { + public void readNumberOfWeeklyTransitionsAttribute( + IntegerAttributeCallback callback + ) { readNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfWeeklyTransitionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfWeeklyTransitionsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfDailyTransitionsAttribute(IntegerAttributeCallback callback) { + public void readNumberOfDailyTransitionsAttribute( + IntegerAttributeCallback callback + ) { readNumberOfDailyTransitionsAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfDailyTransitionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfDailyTransitionsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfDailyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLocalTemperatureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLocalTemperatureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAbsMinHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAbsMinHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAbsMaxHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAbsMaxHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAbsMinCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAbsMinCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAbsMaxCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAbsMaxCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOccupiedCoolingSetpointAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOccupiedCoolingSetpointAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOccupiedCoolingSetpointAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOccupiedHeatingSetpointAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOccupiedHeatingSetpointAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOccupiedHeatingSetpointAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeMinHeatSetpointLimitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeMinHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeMaxHeatSetpointLimitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeMaxHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeMinCoolSetpointLimitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeMinCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeMaxCoolSetpointLimitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeMaxCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinSetpointDeadBandAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeMinSetpointDeadBandAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeMinSetpointDeadBandAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readControlSequenceOfOperationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeControlSequenceOfOperationAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeControlSequenceOfOperationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSystemModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeSystemModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeSystemModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStartOfWeekAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeStartOfWeekAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfWeeklyTransitionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfWeeklyTransitionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfDailyTransitionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfDailyTransitionsAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readLocalTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLocalTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupiedCoolingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOccupiedCoolingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOccupiedCoolingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupiedHeatingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOccupiedHeatingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOccupiedHeatingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMinHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMaxHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMinCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMaxCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinSetpointDeadBandAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMinSetpointDeadBandAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMinSetpointDeadBandAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readControlSequenceOfOperationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeControlSequenceOfOperationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeControlSequenceOfOperationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSystemModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeSystemModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSystemModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartOfWeekAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStartOfWeekAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfDailyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfDailyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 ThermostatUserInterfaceConfigurationCluster extends BaseChipCluster { @@ -16033,1237 +14774,1443 @@ public ThermostatUserInterfaceConfigurationCluster(long devicePtr, int endpointI @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readTemperatureDisplayModeAttribute(IntegerAttributeCallback callback) { + public void readTemperatureDisplayModeAttribute( + IntegerAttributeCallback callback + ) { readTemperatureDisplayModeAttribute(chipClusterPtr, callback); } - - public void writeTemperatureDisplayModeAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value) { writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, null); } - public void writeTemperatureDisplayModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeTemperatureDisplayModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTemperatureDisplayModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readKeypadLockoutAttribute(IntegerAttributeCallback callback) { + public void readKeypadLockoutAttribute( + IntegerAttributeCallback callback + ) { readKeypadLockoutAttribute(chipClusterPtr, callback); } - public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value) { writeKeypadLockoutAttribute(chipClusterPtr, callback, value, null); } - public void writeKeypadLockoutAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeKeypadLockoutAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeKeypadLockoutAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeKeypadLockoutAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readScheduleProgrammingVisibilityAttribute(IntegerAttributeCallback callback) { + public void readScheduleProgrammingVisibilityAttribute( + IntegerAttributeCallback callback + ) { readScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback); } - - public void writeScheduleProgrammingVisibilityAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value) { writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, null); } - public void writeScheduleProgrammingVisibilityAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeScheduleProgrammingVisibilityAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeScheduleProgrammingVisibilityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeScheduleProgrammingVisibilityAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { - subscribeAttributeListAttribute(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 readTemperatureDisplayModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeTemperatureDisplayModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeTemperatureDisplayModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readKeypadLockoutAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeKeypadLockoutAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeKeypadLockoutAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readScheduleProgrammingVisibilityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeScheduleProgrammingVisibilityAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeScheduleProgrammingVisibilityAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - } - - public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 53L; - - public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } - - @Override - public native long initWithDevice(long devicePtr, int endpointId); - - public void resetCounts(DefaultClusterCallback callback) { - resetCounts(chipClusterPtr, callback, null); - } - - public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - private native void resetCounts( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface NeighborTableListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface RouteTableListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public interface SecurityPolicyAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); } - - public interface OperationalDatasetComponentsAttributeCallback { - void onSuccess( - List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public interface ActiveNetworkFaultsListAttributeCallback { - void onSuccess(List valueList); + private native void readTemperatureDisplayModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeTemperatureDisplayModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeTemperatureDisplayModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readKeypadLockoutAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeKeypadLockoutAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeKeypadLockoutAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readScheduleProgrammingVisibilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } - void onError(Exception ex); + public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 53L; - default void onSubscriptionEstablished() {} + public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); + @Override + public native long initWithDevice(long devicePtr, int endpointId); - void onError(Exception ex); + public void resetCounts(DefaultClusterCallback callback + ) { + resetCounts(chipClusterPtr, callback, null); + } - default void onSubscriptionEstablished() {} + public void resetCounts(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface NeighborTableListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface RouteTableListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface SecurityPolicyAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface OperationalDatasetComponentsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ActiveNetworkFaultsListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readChannelAttribute(IntegerAttributeCallback callback) { + public void readChannelAttribute( + IntegerAttributeCallback callback + ) { readChannelAttribute(chipClusterPtr, callback); } - public void subscribeChannelAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeChannelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRoutingRoleAttribute(IntegerAttributeCallback callback) { + public void readRoutingRoleAttribute( + IntegerAttributeCallback callback + ) { readRoutingRoleAttribute(chipClusterPtr, callback); } - public void subscribeRoutingRoleAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRoutingRoleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNetworkNameAttribute(CharStringAttributeCallback callback) { + public void readNetworkNameAttribute( + CharStringAttributeCallback callback + ) { readNetworkNameAttribute(chipClusterPtr, callback); } - public void subscribeNetworkNameAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNetworkNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPanIdAttribute(IntegerAttributeCallback callback) { + public void readPanIdAttribute( + IntegerAttributeCallback callback + ) { readPanIdAttribute(chipClusterPtr, callback); } - public void subscribePanIdAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readExtendedPanIdAttribute(LongAttributeCallback callback) { + public void readExtendedPanIdAttribute( + LongAttributeCallback callback + ) { readExtendedPanIdAttribute(chipClusterPtr, callback); } - public void subscribeExtendedPanIdAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeExtendedPanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMeshLocalPrefixAttribute(OctetStringAttributeCallback callback) { + public void readMeshLocalPrefixAttribute( + OctetStringAttributeCallback callback + ) { readMeshLocalPrefixAttribute(chipClusterPtr, callback); } - public void subscribeMeshLocalPrefixAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMeshLocalPrefixAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute(LongAttributeCallback callback) { + public void readOverrunCountAttribute( + LongAttributeCallback callback + ) { readOverrunCountAttribute(chipClusterPtr, callback); } - public void subscribeOverrunCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNeighborTableListAttribute(NeighborTableListAttributeCallback callback) { + public void readNeighborTableListAttribute( + NeighborTableListAttributeCallback callback + ) { readNeighborTableListAttribute(chipClusterPtr, callback); } - public void subscribeNeighborTableListAttribute( - NeighborTableListAttributeCallback callback, int minInterval, int maxInterval) { + NeighborTableListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNeighborTableListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRouteTableListAttribute(RouteTableListAttributeCallback callback) { + public void readRouteTableListAttribute( + RouteTableListAttributeCallback callback + ) { readRouteTableListAttribute(chipClusterPtr, callback); } - public void subscribeRouteTableListAttribute( - RouteTableListAttributeCallback callback, int minInterval, int maxInterval) { + RouteTableListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeRouteTableListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartitionIdAttribute(LongAttributeCallback callback) { + public void readPartitionIdAttribute( + LongAttributeCallback callback + ) { readPartitionIdAttribute(chipClusterPtr, callback); } - public void subscribePartitionIdAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePartitionIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWeightingAttribute(IntegerAttributeCallback callback) { + public void readWeightingAttribute( + IntegerAttributeCallback callback + ) { readWeightingAttribute(chipClusterPtr, callback); } - public void subscribeWeightingAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWeightingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDataVersionAttribute(IntegerAttributeCallback callback) { + public void readDataVersionAttribute( + IntegerAttributeCallback callback + ) { readDataVersionAttribute(chipClusterPtr, callback); } - public void subscribeDataVersionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStableDataVersionAttribute(IntegerAttributeCallback callback) { + public void readStableDataVersionAttribute( + IntegerAttributeCallback callback + ) { readStableDataVersionAttribute(chipClusterPtr, callback); } - public void subscribeStableDataVersionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStableDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLeaderRouterIdAttribute(IntegerAttributeCallback callback) { + public void readLeaderRouterIdAttribute( + IntegerAttributeCallback callback + ) { readLeaderRouterIdAttribute(chipClusterPtr, callback); } - public void subscribeLeaderRouterIdAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLeaderRouterIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDetachedRoleCountAttribute(IntegerAttributeCallback callback) { + public void readDetachedRoleCountAttribute( + IntegerAttributeCallback callback + ) { readDetachedRoleCountAttribute(chipClusterPtr, callback); } - public void subscribeDetachedRoleCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDetachedRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readChildRoleCountAttribute(IntegerAttributeCallback callback) { + public void readChildRoleCountAttribute( + IntegerAttributeCallback callback + ) { readChildRoleCountAttribute(chipClusterPtr, callback); } - public void subscribeChildRoleCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeChildRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRouterRoleCountAttribute(IntegerAttributeCallback callback) { + public void readRouterRoleCountAttribute( + IntegerAttributeCallback callback + ) { readRouterRoleCountAttribute(chipClusterPtr, callback); } - public void subscribeRouterRoleCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRouterRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLeaderRoleCountAttribute(IntegerAttributeCallback callback) { + public void readLeaderRoleCountAttribute( + IntegerAttributeCallback callback + ) { readLeaderRoleCountAttribute(chipClusterPtr, callback); } - public void subscribeLeaderRoleCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLeaderRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttachAttemptCountAttribute(IntegerAttributeCallback callback) { + public void readAttachAttemptCountAttribute( + IntegerAttributeCallback callback + ) { readAttachAttemptCountAttribute(chipClusterPtr, callback); } - public void subscribeAttachAttemptCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartitionIdChangeCountAttribute(IntegerAttributeCallback callback) { + public void readPartitionIdChangeCountAttribute( + IntegerAttributeCallback callback + ) { readPartitionIdChangeCountAttribute(chipClusterPtr, callback); } - public void subscribePartitionIdChangeCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePartitionIdChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBetterPartitionAttachAttemptCountAttribute(IntegerAttributeCallback callback) { + public void readBetterPartitionAttachAttemptCountAttribute( + IntegerAttributeCallback callback + ) { readBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback); } - public void subscribeBetterPartitionAttachAttemptCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeBetterPartitionAttachAttemptCountAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readParentChangeCountAttribute(IntegerAttributeCallback callback) { + public void readParentChangeCountAttribute( + IntegerAttributeCallback callback + ) { readParentChangeCountAttribute(chipClusterPtr, callback); } - public void subscribeParentChangeCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeParentChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxTotalCountAttribute(LongAttributeCallback callback) { + public void readTxTotalCountAttribute( + LongAttributeCallback callback + ) { readTxTotalCountAttribute(chipClusterPtr, callback); } - public void subscribeTxTotalCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxUnicastCountAttribute(LongAttributeCallback callback) { + public void readTxUnicastCountAttribute( + LongAttributeCallback callback + ) { readTxUnicastCountAttribute(chipClusterPtr, callback); } - public void subscribeTxUnicastCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBroadcastCountAttribute(LongAttributeCallback callback) { + public void readTxBroadcastCountAttribute( + LongAttributeCallback callback + ) { readTxBroadcastCountAttribute(chipClusterPtr, callback); } - public void subscribeTxBroadcastCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxAckRequestedCountAttribute(LongAttributeCallback callback) { + public void readTxAckRequestedCountAttribute( + LongAttributeCallback callback + ) { readTxAckRequestedCountAttribute(chipClusterPtr, callback); } - public void subscribeTxAckRequestedCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxAckedCountAttribute(LongAttributeCallback callback) { + public void readTxAckedCountAttribute( + LongAttributeCallback callback + ) { readTxAckedCountAttribute(chipClusterPtr, callback); } - public void subscribeTxAckedCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxAckedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxNoAckRequestedCountAttribute(LongAttributeCallback callback) { + public void readTxNoAckRequestedCountAttribute( + LongAttributeCallback callback + ) { readTxNoAckRequestedCountAttribute(chipClusterPtr, callback); } - public void subscribeTxNoAckRequestedCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxNoAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDataCountAttribute(LongAttributeCallback callback) { + public void readTxDataCountAttribute( + LongAttributeCallback callback + ) { readTxDataCountAttribute(chipClusterPtr, callback); } - public void subscribeTxDataCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDataPollCountAttribute(LongAttributeCallback callback) { + public void readTxDataPollCountAttribute( + LongAttributeCallback callback + ) { readTxDataPollCountAttribute(chipClusterPtr, callback); } - public void subscribeTxDataPollCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBeaconCountAttribute(LongAttributeCallback callback) { + public void readTxBeaconCountAttribute( + LongAttributeCallback callback + ) { readTxBeaconCountAttribute(chipClusterPtr, callback); } - public void subscribeTxBeaconCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBeaconRequestCountAttribute(LongAttributeCallback callback) { + public void readTxBeaconRequestCountAttribute( + LongAttributeCallback callback + ) { readTxBeaconRequestCountAttribute(chipClusterPtr, callback); } - public void subscribeTxBeaconRequestCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxOtherCountAttribute(LongAttributeCallback callback) { + public void readTxOtherCountAttribute( + LongAttributeCallback callback + ) { readTxOtherCountAttribute(chipClusterPtr, callback); } - public void subscribeTxOtherCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxRetryCountAttribute(LongAttributeCallback callback) { + public void readTxRetryCountAttribute( + LongAttributeCallback callback + ) { readTxRetryCountAttribute(chipClusterPtr, callback); } - public void subscribeTxRetryCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxRetryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDirectMaxRetryExpiryCountAttribute(LongAttributeCallback callback) { + public void readTxDirectMaxRetryExpiryCountAttribute( + LongAttributeCallback callback + ) { readTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); } - public void subscribeTxDirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeTxDirectMaxRetryExpiryCountAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxIndirectMaxRetryExpiryCountAttribute(LongAttributeCallback callback) { + public void readTxIndirectMaxRetryExpiryCountAttribute( + LongAttributeCallback callback + ) { readTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); } - public void subscribeTxIndirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeTxIndirectMaxRetryExpiryCountAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrCcaCountAttribute(LongAttributeCallback callback) { + public void readTxErrCcaCountAttribute( + LongAttributeCallback callback + ) { readTxErrCcaCountAttribute(chipClusterPtr, callback); } - public void subscribeTxErrCcaCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxErrCcaCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrAbortCountAttribute(LongAttributeCallback callback) { + public void readTxErrAbortCountAttribute( + LongAttributeCallback callback + ) { readTxErrAbortCountAttribute(chipClusterPtr, callback); } - public void subscribeTxErrAbortCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxErrAbortCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrBusyChannelCountAttribute(LongAttributeCallback callback) { + public void readTxErrBusyChannelCountAttribute( + LongAttributeCallback callback + ) { readTxErrBusyChannelCountAttribute(chipClusterPtr, callback); } - public void subscribeTxErrBusyChannelCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxErrBusyChannelCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxTotalCountAttribute(LongAttributeCallback callback) { + public void readRxTotalCountAttribute( + LongAttributeCallback callback + ) { readRxTotalCountAttribute(chipClusterPtr, callback); } - public void subscribeRxTotalCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxUnicastCountAttribute(LongAttributeCallback callback) { + public void readRxUnicastCountAttribute( + LongAttributeCallback callback + ) { readRxUnicastCountAttribute(chipClusterPtr, callback); } - public void subscribeRxUnicastCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBroadcastCountAttribute(LongAttributeCallback callback) { + public void readRxBroadcastCountAttribute( + LongAttributeCallback callback + ) { readRxBroadcastCountAttribute(chipClusterPtr, callback); } - public void subscribeRxBroadcastCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDataCountAttribute(LongAttributeCallback callback) { + public void readRxDataCountAttribute( + LongAttributeCallback callback + ) { readRxDataCountAttribute(chipClusterPtr, callback); } - public void subscribeRxDataCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDataPollCountAttribute(LongAttributeCallback callback) { + public void readRxDataPollCountAttribute( + LongAttributeCallback callback + ) { readRxDataPollCountAttribute(chipClusterPtr, callback); } - public void subscribeRxDataPollCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBeaconCountAttribute(LongAttributeCallback callback) { + public void readRxBeaconCountAttribute( + LongAttributeCallback callback + ) { readRxBeaconCountAttribute(chipClusterPtr, callback); } - public void subscribeRxBeaconCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBeaconRequestCountAttribute(LongAttributeCallback callback) { + public void readRxBeaconRequestCountAttribute( + LongAttributeCallback callback + ) { readRxBeaconRequestCountAttribute(chipClusterPtr, callback); } - public void subscribeRxBeaconRequestCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxOtherCountAttribute(LongAttributeCallback callback) { + public void readRxOtherCountAttribute( + LongAttributeCallback callback + ) { readRxOtherCountAttribute(chipClusterPtr, callback); } - public void subscribeRxOtherCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxAddressFilteredCountAttribute(LongAttributeCallback callback) { + public void readRxAddressFilteredCountAttribute( + LongAttributeCallback callback + ) { readRxAddressFilteredCountAttribute(chipClusterPtr, callback); } - public void subscribeRxAddressFilteredCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxAddressFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDestAddrFilteredCountAttribute(LongAttributeCallback callback) { + public void readRxDestAddrFilteredCountAttribute( + LongAttributeCallback callback + ) { readRxDestAddrFilteredCountAttribute(chipClusterPtr, callback); } - public void subscribeRxDestAddrFilteredCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxDestAddrFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDuplicatedCountAttribute(LongAttributeCallback callback) { + public void readRxDuplicatedCountAttribute( + LongAttributeCallback callback + ) { readRxDuplicatedCountAttribute(chipClusterPtr, callback); } - public void subscribeRxDuplicatedCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxDuplicatedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrNoFrameCountAttribute(LongAttributeCallback callback) { + public void readRxErrNoFrameCountAttribute( + LongAttributeCallback callback + ) { readRxErrNoFrameCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrNoFrameCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxErrNoFrameCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrUnknownNeighborCountAttribute(LongAttributeCallback callback) { + public void readRxErrUnknownNeighborCountAttribute( + LongAttributeCallback callback + ) { readRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrUnknownNeighborCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeRxErrUnknownNeighborCountAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrInvalidSrcAddrCountAttribute(LongAttributeCallback callback) { + public void readRxErrInvalidSrcAddrCountAttribute( + LongAttributeCallback callback + ) { readRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrInvalidSrcAddrCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeRxErrInvalidSrcAddrCountAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrSecCountAttribute(LongAttributeCallback callback) { + public void readRxErrSecCountAttribute( + LongAttributeCallback callback + ) { readRxErrSecCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrSecCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxErrSecCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrFcsCountAttribute(LongAttributeCallback callback) { + public void readRxErrFcsCountAttribute( + LongAttributeCallback callback + ) { readRxErrFcsCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrFcsCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxErrFcsCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrOtherCountAttribute(LongAttributeCallback callback) { + public void readRxErrOtherCountAttribute( + LongAttributeCallback callback + ) { readRxErrOtherCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrOtherCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxErrOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveTimestampAttribute(LongAttributeCallback callback) { + public void readActiveTimestampAttribute( + LongAttributeCallback callback + ) { readActiveTimestampAttribute(chipClusterPtr, callback); } - public void subscribeActiveTimestampAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActiveTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPendingTimestampAttribute(LongAttributeCallback callback) { + public void readPendingTimestampAttribute( + LongAttributeCallback callback + ) { readPendingTimestampAttribute(chipClusterPtr, callback); } - public void subscribePendingTimestampAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePendingTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDelayAttribute(LongAttributeCallback callback) { + public void readDelayAttribute( + LongAttributeCallback callback + ) { readDelayAttribute(chipClusterPtr, callback); } - public void subscribeDelayAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSecurityPolicyAttribute(SecurityPolicyAttributeCallback callback) { + public void readSecurityPolicyAttribute( + SecurityPolicyAttributeCallback callback + ) { readSecurityPolicyAttribute(chipClusterPtr, callback); } - public void subscribeSecurityPolicyAttribute( - SecurityPolicyAttributeCallback callback, int minInterval, int maxInterval) { - subscribeSecurityPolicyAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readChannelMaskAttribute(OctetStringAttributeCallback callback) { - readChannelMaskAttribute(chipClusterPtr, callback); - } - - public void subscribeChannelMaskAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { - subscribeChannelMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readOperationalDatasetComponentsAttribute( - OperationalDatasetComponentsAttributeCallback callback) { - readOperationalDatasetComponentsAttribute(chipClusterPtr, callback); - } - - public void subscribeOperationalDatasetComponentsAttribute( - OperationalDatasetComponentsAttributeCallback callback, int minInterval, int maxInterval) { - subscribeOperationalDatasetComponentsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readActiveNetworkFaultsListAttribute( - ActiveNetworkFaultsListAttributeCallback callback) { - readActiveNetworkFaultsListAttribute(chipClusterPtr, callback); - } - - public void subscribeActiveNetworkFaultsListAttribute( - ActiveNetworkFaultsListAttributeCallback callback, int minInterval, int maxInterval) { - subscribeActiveNetworkFaultsListAttribute(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 readChannelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeChannelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRoutingRoleAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRoutingRoleAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNetworkNameAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeNetworkNameAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readPanIdAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePanIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readExtendedPanIdAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeExtendedPanIdAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMeshLocalPrefixAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void subscribeMeshLocalPrefixAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNeighborTableListAttribute( - long chipClusterPtr, NeighborTableListAttributeCallback callback); - - private native void subscribeNeighborTableListAttribute( - long chipClusterPtr, - NeighborTableListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readRouteTableListAttribute( - long chipClusterPtr, RouteTableListAttributeCallback callback); - - private native void subscribeRouteTableListAttribute( - long chipClusterPtr, - RouteTableListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readPartitionIdAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePartitionIdAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readWeightingAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeWeightingAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDataVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeDataVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStableDataVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeStableDataVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLeaderRouterIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLeaderRouterIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDetachedRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeDetachedRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readChildRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeChildRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRouterRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRouterRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLeaderRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLeaderRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAttachAttemptCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAttachAttemptCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPartitionIdChangeCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePartitionIdChangeCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBetterPartitionAttachAttemptCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBetterPartitionAttachAttemptCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readParentChangeCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeParentChangeCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxTotalCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxTotalCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxUnicastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxUnicastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxBroadcastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxBroadcastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxAckRequestedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxAckRequestedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxAckedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxAckedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxNoAckRequestedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxNoAckRequestedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxDataCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxDataCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxDataPollCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxDataPollCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxBeaconCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxBeaconCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxBeaconRequestCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxBeaconRequestCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxRetryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxRetryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxDirectMaxRetryExpiryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxDirectMaxRetryExpiryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxIndirectMaxRetryExpiryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxIndirectMaxRetryExpiryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxErrCcaCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxErrCcaCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxErrAbortCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxErrAbortCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxErrBusyChannelCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxErrBusyChannelCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxTotalCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxTotalCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxUnicastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxUnicastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxBroadcastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxBroadcastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxDataCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxDataCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxDataPollCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxDataPollCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxBeaconCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxBeaconCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxBeaconRequestCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxBeaconRequestCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxAddressFilteredCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxAddressFilteredCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxDestAddrFilteredCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxDestAddrFilteredCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxDuplicatedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxDuplicatedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrNoFrameCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrNoFrameCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrUnknownNeighborCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrUnknownNeighborCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrInvalidSrcAddrCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrInvalidSrcAddrCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrSecCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrSecCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrFcsCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrFcsCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActiveTimestampAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeActiveTimestampAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPendingTimestampAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePendingTimestampAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDelayAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeDelayAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSecurityPolicyAttribute( - long chipClusterPtr, SecurityPolicyAttributeCallback callback); - - private native void subscribeSecurityPolicyAttribute( - long chipClusterPtr, - SecurityPolicyAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readChannelMaskAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void subscribeChannelMaskAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOperationalDatasetComponentsAttribute( - long chipClusterPtr, OperationalDatasetComponentsAttributeCallback callback); - - private native void subscribeOperationalDatasetComponentsAttribute( - long chipClusterPtr, - OperationalDatasetComponentsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readActiveNetworkFaultsListAttribute( - long chipClusterPtr, ActiveNetworkFaultsListAttributeCallback callback); + SecurityPolicyAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSecurityPolicyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void subscribeActiveNetworkFaultsListAttribute( - long chipClusterPtr, - ActiveNetworkFaultsListAttributeCallback callback, - int minInterval, - int maxInterval); + public void readChannelMaskAttribute( + OctetStringAttributeCallback callback + ) { + readChannelMaskAttribute(chipClusterPtr, callback); + } + public void subscribeChannelMaskAttribute( + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeChannelMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); + public void readOperationalDatasetComponentsAttribute( + OperationalDatasetComponentsAttributeCallback callback + ) { + readOperationalDatasetComponentsAttribute(chipClusterPtr, callback); + } + public void subscribeOperationalDatasetComponentsAttribute( + OperationalDatasetComponentsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOperationalDatasetComponentsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback callback, - int minInterval, - int maxInterval); + public void readActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback + ) { + readActiveNetworkFaultsListAttribute(chipClusterPtr, callback); + } + public void subscribeActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeActiveNetworkFaultsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readFeatureMapAttribute( - long chipClusterPtr, LongAttributeCallback callback); + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void subscribeFeatureMapAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + 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 subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readChannelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeChannelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRoutingRoleAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRoutingRoleAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNetworkNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeNetworkNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPanIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePanIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readExtendedPanIdAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeExtendedPanIdAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeshLocalPrefixAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + private native void subscribeMeshLocalPrefixAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNeighborTableListAttribute(long chipClusterPtr, + NeighborTableListAttributeCallback callback + ); + private native void subscribeNeighborTableListAttribute(long chipClusterPtr, + NeighborTableListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRouteTableListAttribute(long chipClusterPtr, + RouteTableListAttributeCallback callback + ); + private native void subscribeRouteTableListAttribute(long chipClusterPtr, + RouteTableListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPartitionIdAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePartitionIdAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWeightingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeWeightingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDataVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDataVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStableDataVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStableDataVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLeaderRouterIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLeaderRouterIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDetachedRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDetachedRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readChildRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeChildRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRouterRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRouterRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLeaderRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLeaderRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPartitionIdChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePartitionIdChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readParentChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeParentChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxAckedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxAckedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxNoAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxNoAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxRetryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxRetryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrCcaCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrCcaCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrAbortCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrAbortCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrBusyChannelCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrBusyChannelCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxAddressFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxAddressFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDestAddrFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDestAddrFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDuplicatedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDuplicatedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrNoFrameCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrNoFrameCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrUnknownNeighborCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrUnknownNeighborCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrSecCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrSecCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrFcsCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrFcsCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveTimestampAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeActiveTimestampAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPendingTimestampAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePendingTimestampAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDelayAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeDelayAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSecurityPolicyAttribute(long chipClusterPtr, + SecurityPolicyAttributeCallback callback + ); + private native void subscribeSecurityPolicyAttribute(long chipClusterPtr, + SecurityPolicyAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readChannelMaskAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + private native void subscribeChannelMaskAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOperationalDatasetComponentsAttribute(long chipClusterPtr, + OperationalDatasetComponentsAttributeCallback callback + ); + private native void subscribeOperationalDatasetComponentsAttribute(long chipClusterPtr, + OperationalDatasetComponentsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readActiveNetworkFaultsListAttribute(long chipClusterPtr, + ActiveNetworkFaultsListAttributeCallback callback + ); + private native void subscribeActiveNetworkFaultsListAttribute(long chipClusterPtr, + ActiveNetworkFaultsListAttributeCallback 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 TimeFormatLocalizationCluster extends BaseChipCluster { @@ -17276,107 +16223,105 @@ public TimeFormatLocalizationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SupportedCalendarTypesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface SupportedCalendarTypesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readHourFormatAttribute(IntegerAttributeCallback callback) { + public void readHourFormatAttribute( + IntegerAttributeCallback callback + ) { readHourFormatAttribute(chipClusterPtr, callback); } - public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value) { writeHourFormatAttribute(chipClusterPtr, callback, value, null); } - public void writeHourFormatAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeHourFormatAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeHourFormatAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeHourFormatAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveCalendarTypeAttribute(IntegerAttributeCallback callback) { + public void readActiveCalendarTypeAttribute( + IntegerAttributeCallback callback + ) { readActiveCalendarTypeAttribute(chipClusterPtr, callback); } - public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value) { writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, null); } - public void writeActiveCalendarTypeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeActiveCalendarTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActiveCalendarTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readSupportedCalendarTypesAttribute( - SupportedCalendarTypesAttributeCallback callback) { + SupportedCalendarTypesAttributeCallback callback + ) { readSupportedCalendarTypesAttribute(chipClusterPtr, callback); } - public void subscribeSupportedCalendarTypesAttribute( - SupportedCalendarTypesAttributeCallback callback, int minInterval, int maxInterval) { + SupportedCalendarTypesAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeSupportedCalendarTypesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readHourFormatAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeHourFormatAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeHourFormatAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActiveCalendarTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeActiveCalendarTypeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeActiveCalendarTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSupportedCalendarTypesAttribute( - long chipClusterPtr, SupportedCalendarTypesAttributeCallback callback); - - private native void subscribeSupportedCalendarTypesAttribute( - long chipClusterPtr, - SupportedCalendarTypesAttributeCallback 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); + private native void readHourFormatAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeHourFormatAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeHourFormatAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveCalendarTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeActiveCalendarTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeActiveCalendarTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedCalendarTypesAttribute(long chipClusterPtr, + SupportedCalendarTypesAttributeCallback callback + ); + private native void subscribeSupportedCalendarTypesAttribute(long chipClusterPtr, + SupportedCalendarTypesAttributeCallback 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 UnitLocalizationCluster extends BaseChipCluster { @@ -17389,65 +16334,72 @@ public UnitLocalizationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void readTemperatureUnitAttribute(IntegerAttributeCallback callback) { + + public void readTemperatureUnitAttribute( + IntegerAttributeCallback callback + ) { readTemperatureUnitAttribute(chipClusterPtr, callback); } - public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value) { writeTemperatureUnitAttribute(chipClusterPtr, callback, value, null); } - public void writeTemperatureUnitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeTemperatureUnitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeTemperatureUnitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTemperatureUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTemperatureUnitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeTemperatureUnitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeTemperatureUnitAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readTemperatureUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeTemperatureUnitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeTemperatureUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 UserLabelCluster extends BaseChipCluster { @@ -17460,61 +16412,58 @@ public UserLabelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LabelListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface LabelListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readLabelListAttribute(LabelListAttributeCallback callback) { + public void readLabelListAttribute( + LabelListAttributeCallback callback + ) { readLabelListAttribute(chipClusterPtr, callback); } - - public void writeLabelListAttribute( - DefaultClusterCallback callback, ArrayList value) { + public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value) { writeLabelListAttribute(chipClusterPtr, callback, value, null); } - public void writeLabelListAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { + public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeLabelListAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLabelListAttribute( - LabelListAttributeCallback callback, int minInterval, int maxInterval) { + LabelListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLabelListAttribute( - long chipClusterPtr, LabelListAttributeCallback callback); - - private native void writeLabelListAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLabelListAttribute( - long chipClusterPtr, LabelListAttributeCallback callback, int minInterval, int maxInterval); + private native void readLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback callback + ); - private native void readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + private native void writeLabelListAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback callback + , int minInterval, int maxInterval); - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 WakeOnLanCluster extends BaseChipCluster { @@ -17527,64 +16476,68 @@ public WakeOnLanCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readWakeOnLanMacAddressAttribute(CharStringAttributeCallback callback) { + public void readWakeOnLanMacAddressAttribute( + CharStringAttributeCallback callback + ) { readWakeOnLanMacAddressAttribute(chipClusterPtr, callback); } - public void subscribeWakeOnLanMacAddressAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWakeOnLanMacAddressAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readWakeOnLanMacAddressAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeWakeOnLanMacAddressAttribute( - long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readWakeOnLanMacAddressAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeWakeOnLanMacAddressAttribute(long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class WiFiNetworkDiagnosticsCluster extends BaseChipCluster { @@ -17597,272 +16550,329 @@ public WiFiNetworkDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetCounts(DefaultClusterCallback callback) { + public void resetCounts(DefaultClusterCallback callback + ) { resetCounts(chipClusterPtr, callback, null); } - public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void resetCounts(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); - private native void resetCounts( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readBssidAttribute(OctetStringAttributeCallback callback) { + public void readBssidAttribute( + OctetStringAttributeCallback callback + ) { readBssidAttribute(chipClusterPtr, callback); } - public void subscribeBssidAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBssidAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSecurityTypeAttribute(IntegerAttributeCallback callback) { + public void readSecurityTypeAttribute( + IntegerAttributeCallback callback + ) { readSecurityTypeAttribute(chipClusterPtr, callback); } - public void subscribeSecurityTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSecurityTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWiFiVersionAttribute(IntegerAttributeCallback callback) { + public void readWiFiVersionAttribute( + IntegerAttributeCallback callback + ) { readWiFiVersionAttribute(chipClusterPtr, callback); } - public void subscribeWiFiVersionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWiFiVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readChannelNumberAttribute(IntegerAttributeCallback callback) { + public void readChannelNumberAttribute( + IntegerAttributeCallback callback + ) { readChannelNumberAttribute(chipClusterPtr, callback); } - public void subscribeChannelNumberAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeChannelNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRssiAttribute(IntegerAttributeCallback callback) { + public void readRssiAttribute( + IntegerAttributeCallback callback + ) { readRssiAttribute(chipClusterPtr, callback); } - public void subscribeRssiAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRssiAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBeaconLostCountAttribute(LongAttributeCallback callback) { + public void readBeaconLostCountAttribute( + LongAttributeCallback callback + ) { readBeaconLostCountAttribute(chipClusterPtr, callback); } - public void subscribeBeaconLostCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBeaconLostCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBeaconRxCountAttribute(LongAttributeCallback callback) { + public void readBeaconRxCountAttribute( + LongAttributeCallback callback + ) { readBeaconRxCountAttribute(chipClusterPtr, callback); } - public void subscribeBeaconRxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBeaconRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketMulticastRxCountAttribute(LongAttributeCallback callback) { + public void readPacketMulticastRxCountAttribute( + LongAttributeCallback callback + ) { readPacketMulticastRxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketMulticastRxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketMulticastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketMulticastTxCountAttribute(LongAttributeCallback callback) { + public void readPacketMulticastTxCountAttribute( + LongAttributeCallback callback + ) { readPacketMulticastTxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketMulticastTxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketMulticastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketUnicastRxCountAttribute(LongAttributeCallback callback) { + public void readPacketUnicastRxCountAttribute( + LongAttributeCallback callback + ) { readPacketUnicastRxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketUnicastRxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketUnicastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketUnicastTxCountAttribute(LongAttributeCallback callback) { + public void readPacketUnicastTxCountAttribute( + LongAttributeCallback callback + ) { readPacketUnicastTxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketUnicastTxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketUnicastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentMaxRateAttribute(LongAttributeCallback callback) { + public void readCurrentMaxRateAttribute( + LongAttributeCallback callback + ) { readCurrentMaxRateAttribute(chipClusterPtr, callback); } - public void subscribeCurrentMaxRateAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentMaxRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute(LongAttributeCallback callback) { + public void readOverrunCountAttribute( + LongAttributeCallback callback + ) { readOverrunCountAttribute(chipClusterPtr, callback); } - public void subscribeOverrunCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBssidAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void subscribeBssidAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSecurityTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSecurityTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readWiFiVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeWiFiVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readChannelNumberAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeChannelNumberAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRssiAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRssiAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBeaconLostCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeBeaconLostCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBeaconRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeBeaconRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketMulticastRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketMulticastRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketMulticastTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketMulticastTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketUnicastRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketUnicastRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketUnicastTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketUnicastTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentMaxRateAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeCurrentMaxRateAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback 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); + private native void readBssidAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + private native void subscribeBssidAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSecurityTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSecurityTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWiFiVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeWiFiVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readChannelNumberAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeChannelNumberAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRssiAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRssiAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBeaconLostCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeBeaconLostCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBeaconRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeBeaconRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketMulticastRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketMulticastRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketMulticastTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketMulticastTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketUnicastRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketUnicastRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketUnicastTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketUnicastTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentMaxRateAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCurrentMaxRateAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback 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 WindowCoveringCluster extends BaseChipCluster { @@ -17875,581 +16885,556 @@ public WindowCoveringCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void downOrClose(DefaultClusterCallback callback) { + public void downOrClose(DefaultClusterCallback callback + ) { downOrClose(chipClusterPtr, callback, null); } - public void downOrClose(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void downOrClose(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { downOrClose(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void goToLiftPercentage( - DefaultClusterCallback callback, - Integer liftPercentageValue, - Integer liftPercent100thsValue) { - goToLiftPercentage( - chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, null); + public void goToLiftPercentage(DefaultClusterCallback callback + , Integer liftPercentageValue, Integer liftPercent100thsValue) { + goToLiftPercentage(chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, null); } - public void goToLiftPercentage( - DefaultClusterCallback callback, - Integer liftPercentageValue, - Integer liftPercent100thsValue, - int timedInvokeTimeoutMs) { - goToLiftPercentage( - chipClusterPtr, - callback, - liftPercentageValue, - liftPercent100thsValue, - timedInvokeTimeoutMs); + public void goToLiftPercentage(DefaultClusterCallback callback + , Integer liftPercentageValue, Integer liftPercent100thsValue + , int timedInvokeTimeoutMs) { + goToLiftPercentage(chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, timedInvokeTimeoutMs); } - public void goToLiftValue(DefaultClusterCallback callback, Integer liftValue) { + public void goToLiftValue(DefaultClusterCallback callback + , Integer liftValue) { goToLiftValue(chipClusterPtr, callback, liftValue, null); } - public void goToLiftValue( - DefaultClusterCallback callback, Integer liftValue, int timedInvokeTimeoutMs) { + public void goToLiftValue(DefaultClusterCallback callback + , Integer liftValue + , int timedInvokeTimeoutMs) { goToLiftValue(chipClusterPtr, callback, liftValue, timedInvokeTimeoutMs); } - public void goToTiltPercentage( - DefaultClusterCallback callback, - Integer tiltPercentageValue, - Integer tiltPercent100thsValue) { - goToTiltPercentage( - chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, null); + public void goToTiltPercentage(DefaultClusterCallback callback + , Integer tiltPercentageValue, Integer tiltPercent100thsValue) { + goToTiltPercentage(chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, null); } - public void goToTiltPercentage( - DefaultClusterCallback callback, - Integer tiltPercentageValue, - Integer tiltPercent100thsValue, - int timedInvokeTimeoutMs) { - goToTiltPercentage( - chipClusterPtr, - callback, - tiltPercentageValue, - tiltPercent100thsValue, - timedInvokeTimeoutMs); + public void goToTiltPercentage(DefaultClusterCallback callback + , Integer tiltPercentageValue, Integer tiltPercent100thsValue + , int timedInvokeTimeoutMs) { + goToTiltPercentage(chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, timedInvokeTimeoutMs); } - public void goToTiltValue(DefaultClusterCallback callback, Integer tiltValue) { + public void goToTiltValue(DefaultClusterCallback callback + , Integer tiltValue) { goToTiltValue(chipClusterPtr, callback, tiltValue, null); } - public void goToTiltValue( - DefaultClusterCallback callback, Integer tiltValue, int timedInvokeTimeoutMs) { + public void goToTiltValue(DefaultClusterCallback callback + , Integer tiltValue + , int timedInvokeTimeoutMs) { goToTiltValue(chipClusterPtr, callback, tiltValue, timedInvokeTimeoutMs); } - public void stopMotion(DefaultClusterCallback callback) { + public void stopMotion(DefaultClusterCallback callback + ) { stopMotion(chipClusterPtr, callback, null); } - public void stopMotion(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void stopMotion(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { stopMotion(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void upOrOpen(DefaultClusterCallback callback) { + public void upOrOpen(DefaultClusterCallback callback + ) { upOrOpen(chipClusterPtr, callback, null); } - public void upOrOpen(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void upOrOpen(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { upOrOpen(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void downOrClose(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToLiftPercentage(long chipClusterPtr, DefaultClusterCallback Callback + , Integer liftPercentageValue, Integer liftPercent100thsValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToLiftValue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer liftValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToTiltPercentage(long chipClusterPtr, DefaultClusterCallback Callback + , Integer tiltPercentageValue, Integer tiltPercent100thsValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToTiltValue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer tiltValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopMotion(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void upOrOpen(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface CurrentPositionLiftAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentPositionTiltAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentPositionLiftPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentPositionTiltPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface TargetPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface TargetPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void downOrClose( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void goToLiftPercentage( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer liftPercentageValue, - Integer liftPercent100thsValue, - @Nullable Integer timedInvokeTimeoutMs); - - private native void goToLiftValue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer liftValue, - @Nullable Integer timedInvokeTimeoutMs); - - private native void goToTiltPercentage( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer tiltPercentageValue, - Integer tiltPercent100thsValue, - @Nullable Integer timedInvokeTimeoutMs); - - private native void goToTiltValue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer tiltValue, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopMotion( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void upOrOpen( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface CurrentPositionLiftAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentPositionTiltAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentPositionLiftPercentageAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentPositionTiltPercentageAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface TargetPositionLiftPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface TargetPositionTiltPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentPositionLiftPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentPositionTiltPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readTypeAttribute(IntegerAttributeCallback callback) { + public void readTypeAttribute( + IntegerAttributeCallback callback + ) { readTypeAttribute(chipClusterPtr, callback); } - public void subscribeTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionLiftAttribute(CurrentPositionLiftAttributeCallback callback) { + public void readCurrentPositionLiftAttribute( + CurrentPositionLiftAttributeCallback callback + ) { readCurrentPositionLiftAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionLiftAttribute( - CurrentPositionLiftAttributeCallback callback, int minInterval, int maxInterval) { + CurrentPositionLiftAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeCurrentPositionLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionTiltAttribute(CurrentPositionTiltAttributeCallback callback) { + public void readCurrentPositionTiltAttribute( + CurrentPositionTiltAttributeCallback callback + ) { readCurrentPositionTiltAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionTiltAttribute( - CurrentPositionTiltAttributeCallback callback, int minInterval, int maxInterval) { + CurrentPositionTiltAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeCurrentPositionTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readConfigStatusAttribute(IntegerAttributeCallback callback) { + public void readConfigStatusAttribute( + IntegerAttributeCallback callback + ) { readConfigStatusAttribute(chipClusterPtr, callback); } - public void subscribeConfigStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeConfigStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionLiftPercentageAttribute( - CurrentPositionLiftPercentageAttributeCallback callback) { + CurrentPositionLiftPercentageAttributeCallback callback + ) { readCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionLiftPercentageAttribute( - CurrentPositionLiftPercentageAttributeCallback callback, int minInterval, int maxInterval) { - subscribeCurrentPositionLiftPercentageAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionLiftPercentageAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionTiltPercentageAttribute( - CurrentPositionTiltPercentageAttributeCallback callback) { + CurrentPositionTiltPercentageAttributeCallback callback + ) { readCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionTiltPercentageAttribute( - CurrentPositionTiltPercentageAttributeCallback callback, int minInterval, int maxInterval) { - subscribeCurrentPositionTiltPercentageAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionTiltPercentageAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperationalStatusAttribute(IntegerAttributeCallback callback) { + public void readOperationalStatusAttribute( + IntegerAttributeCallback callback + ) { readOperationalStatusAttribute(chipClusterPtr, callback); } - public void subscribeOperationalStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOperationalStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTargetPositionLiftPercent100thsAttribute( - TargetPositionLiftPercent100thsAttributeCallback callback) { + TargetPositionLiftPercent100thsAttributeCallback callback + ) { readTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback); } - public void subscribeTargetPositionLiftPercent100thsAttribute( - TargetPositionLiftPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval) { - subscribeTargetPositionLiftPercent100thsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + TargetPositionLiftPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTargetPositionTiltPercent100thsAttribute( - TargetPositionTiltPercent100thsAttributeCallback callback) { + TargetPositionTiltPercent100thsAttributeCallback callback + ) { readTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback); } - public void subscribeTargetPositionTiltPercent100thsAttribute( - TargetPositionTiltPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval) { - subscribeTargetPositionTiltPercent100thsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + TargetPositionTiltPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEndProductTypeAttribute(IntegerAttributeCallback callback) { + public void readEndProductTypeAttribute( + IntegerAttributeCallback callback + ) { readEndProductTypeAttribute(chipClusterPtr, callback); } - public void subscribeEndProductTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEndProductTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionLiftPercent100thsAttribute( - CurrentPositionLiftPercent100thsAttributeCallback callback) { + CurrentPositionLiftPercent100thsAttributeCallback callback + ) { readCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionLiftPercent100thsAttribute( - CurrentPositionLiftPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval) { - subscribeCurrentPositionLiftPercent100thsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionLiftPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionTiltPercent100thsAttribute( - CurrentPositionTiltPercent100thsAttributeCallback callback) { + CurrentPositionTiltPercent100thsAttributeCallback callback + ) { readCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionTiltPercent100thsAttribute( - CurrentPositionTiltPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval) { - subscribeCurrentPositionTiltPercent100thsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionTiltPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledOpenLimitLiftAttribute(IntegerAttributeCallback callback) { + public void readInstalledOpenLimitLiftAttribute( + IntegerAttributeCallback callback + ) { readInstalledOpenLimitLiftAttribute(chipClusterPtr, callback); } - public void subscribeInstalledOpenLimitLiftAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInstalledOpenLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledClosedLimitLiftAttribute(IntegerAttributeCallback callback) { + public void readInstalledClosedLimitLiftAttribute( + IntegerAttributeCallback callback + ) { readInstalledClosedLimitLiftAttribute(chipClusterPtr, callback); } - public void subscribeInstalledClosedLimitLiftAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeInstalledClosedLimitLiftAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstalledClosedLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledOpenLimitTiltAttribute(IntegerAttributeCallback callback) { + public void readInstalledOpenLimitTiltAttribute( + IntegerAttributeCallback callback + ) { readInstalledOpenLimitTiltAttribute(chipClusterPtr, callback); } - public void subscribeInstalledOpenLimitTiltAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInstalledOpenLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledClosedLimitTiltAttribute(IntegerAttributeCallback callback) { + public void readInstalledClosedLimitTiltAttribute( + IntegerAttributeCallback callback + ) { readInstalledClosedLimitTiltAttribute(chipClusterPtr, callback); } - public void subscribeInstalledClosedLimitTiltAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeInstalledClosedLimitTiltAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstalledClosedLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readModeAttribute(IntegerAttributeCallback callback) { + public void readModeAttribute( + IntegerAttributeCallback callback + ) { readModeAttribute(chipClusterPtr, callback); } - public void writeModeAttribute(DefaultClusterCallback callback, Integer value) { writeModeAttribute(chipClusterPtr, callback, value, null); } - public void writeModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSafetyStatusAttribute(IntegerAttributeCallback callback) { + public void readSafetyStatusAttribute( + IntegerAttributeCallback callback + ) { readSafetyStatusAttribute(chipClusterPtr, callback); } - public void subscribeSafetyStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftAttribute( - long chipClusterPtr, CurrentPositionLiftAttributeCallback callback); - - private native void subscribeCurrentPositionLiftAttribute( - long chipClusterPtr, - CurrentPositionLiftAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentPositionTiltAttribute( - long chipClusterPtr, CurrentPositionTiltAttributeCallback callback); - - private native void subscribeCurrentPositionTiltAttribute( - long chipClusterPtr, - CurrentPositionTiltAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readConfigStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeConfigStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftPercentageAttribute( - long chipClusterPtr, CurrentPositionLiftPercentageAttributeCallback callback); - - private native void subscribeCurrentPositionLiftPercentageAttribute( - long chipClusterPtr, - CurrentPositionLiftPercentageAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentPositionTiltPercentageAttribute( - long chipClusterPtr, CurrentPositionTiltPercentageAttributeCallback callback); - - private native void subscribeCurrentPositionTiltPercentageAttribute( - long chipClusterPtr, - CurrentPositionTiltPercentageAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOperationalStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeOperationalStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTargetPositionLiftPercent100thsAttribute( - long chipClusterPtr, TargetPositionLiftPercent100thsAttributeCallback callback); - - private native void subscribeTargetPositionLiftPercent100thsAttribute( - long chipClusterPtr, - TargetPositionLiftPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readTargetPositionTiltPercent100thsAttribute( - long chipClusterPtr, TargetPositionTiltPercent100thsAttributeCallback callback); - - private native void subscribeTargetPositionTiltPercent100thsAttribute( - long chipClusterPtr, - TargetPositionTiltPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readEndProductTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeEndProductTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftPercent100thsAttribute( - long chipClusterPtr, CurrentPositionLiftPercent100thsAttributeCallback callback); - - private native void subscribeCurrentPositionLiftPercent100thsAttribute( - long chipClusterPtr, - CurrentPositionLiftPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentPositionTiltPercent100thsAttribute( - long chipClusterPtr, CurrentPositionTiltPercent100thsAttributeCallback callback); - - private native void subscribeCurrentPositionTiltPercent100thsAttribute( - long chipClusterPtr, - CurrentPositionTiltPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readInstalledOpenLimitLiftAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeInstalledOpenLimitLiftAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInstalledClosedLimitLiftAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeInstalledClosedLimitLiftAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInstalledOpenLimitTiltAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeInstalledOpenLimitTiltAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInstalledClosedLimitTiltAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeInstalledClosedLimitTiltAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSafetyStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSafetyStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftAttribute(long chipClusterPtr, + CurrentPositionLiftAttributeCallback callback + ); + private native void subscribeCurrentPositionLiftAttribute(long chipClusterPtr, + CurrentPositionLiftAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentPositionTiltAttribute(long chipClusterPtr, + CurrentPositionTiltAttributeCallback callback + ); + private native void subscribeCurrentPositionTiltAttribute(long chipClusterPtr, + CurrentPositionTiltAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readConfigStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeConfigStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercentageAttribute(long chipClusterPtr, + CurrentPositionLiftPercentageAttributeCallback callback + ); + private native void subscribeCurrentPositionLiftPercentageAttribute(long chipClusterPtr, + CurrentPositionLiftPercentageAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentPositionTiltPercentageAttribute(long chipClusterPtr, + CurrentPositionTiltPercentageAttributeCallback callback + ); + private native void subscribeCurrentPositionTiltPercentageAttribute(long chipClusterPtr, + CurrentPositionTiltPercentageAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOperationalStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOperationalStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, + TargetPositionLiftPercent100thsAttributeCallback callback + ); + private native void subscribeTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, + TargetPositionLiftPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, + TargetPositionTiltPercent100thsAttributeCallback callback + ); + private native void subscribeTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, + TargetPositionTiltPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEndProductTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEndProductTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, + CurrentPositionLiftPercent100thsAttributeCallback callback + ); + private native void subscribeCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, + CurrentPositionLiftPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, + CurrentPositionTiltPercent100thsAttributeCallback callback + ); + private native void subscribeCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, + CurrentPositionTiltPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readInstalledOpenLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledOpenLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledClosedLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstalledOpenLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledOpenLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledClosedLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback 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); } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java index bbbf6488468e15..23446754ab399f 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java @@ -24,1975 +24,2110 @@ import java.util.Optional; public class ChipStructs { - public static class AccessControlClusterTarget { - public @Nullable Long cluster; - public @Nullable Integer endpoint; - public @Nullable Long deviceType; - - public AccessControlClusterTarget( - @Nullable Long cluster, @Nullable Integer endpoint, @Nullable Long deviceType) { - this.cluster = cluster; - this.endpoint = endpoint; - this.deviceType = deviceType; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterTarget {\n"); - output.append("\tcluster: "); - output.append(cluster); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("\tdeviceType: "); - output.append(deviceType); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class AccessControlClusterAccessControlEntry { - public Integer fabricIndex; - public Integer privilege; - public Integer authMode; - public @Nullable ArrayList subjects; - public @Nullable ArrayList targets; - - public AccessControlClusterAccessControlEntry( - Integer fabricIndex, - Integer privilege, - Integer authMode, - @Nullable ArrayList subjects, - @Nullable ArrayList targets) { - this.fabricIndex = fabricIndex; - this.privilege = privilege; - this.authMode = authMode; - this.subjects = subjects; - this.targets = targets; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterAccessControlEntry {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tprivilege: "); - output.append(privilege); - output.append("\n"); - output.append("\tauthMode: "); - output.append(authMode); - output.append("\n"); - output.append("\tsubjects: "); - output.append(subjects); - output.append("\n"); - output.append("\ttargets: "); - output.append(targets); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class AccessControlClusterExtensionEntry { - public Integer fabricIndex; - public byte[] data; - - public AccessControlClusterExtensionEntry(Integer fabricIndex, byte[] data) { - this.fabricIndex = fabricIndex; - this.data = data; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterExtensionEntry {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tdata: "); - output.append(Arrays.toString(data)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ApplicationBasicClusterApplicationBasicApplication { - public Integer catalogVendorId; - public String applicationId; - - public ApplicationBasicClusterApplicationBasicApplication( - Integer catalogVendorId, String applicationId) { - this.catalogVendorId = catalogVendorId; - this.applicationId = applicationId; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationBasicClusterApplicationBasicApplication {\n"); - output.append("\tcatalogVendorId: "); - output.append(catalogVendorId); - output.append("\n"); - output.append("\tapplicationId: "); - output.append(applicationId); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ApplicationLauncherClusterApplicationLauncherApplication { - public Integer catalogVendorId; - public String applicationId; - - public ApplicationLauncherClusterApplicationLauncherApplication( - Integer catalogVendorId, String applicationId) { - this.catalogVendorId = catalogVendorId; - this.applicationId = applicationId; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationLauncherClusterApplicationLauncherApplication {\n"); - output.append("\tcatalogVendorId: "); - output.append(catalogVendorId); - output.append("\n"); - output.append("\tapplicationId: "); - output.append(applicationId); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ApplicationLauncherClusterApplicationEP { - public ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application; - public String endpoint; - - public ApplicationLauncherClusterApplicationEP( - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - String endpoint) { - this.application = application; - this.endpoint = endpoint; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationLauncherClusterApplicationEP {\n"); - output.append("\tapplication: "); - output.append(application); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class AudioOutputClusterOutputInfo { - public Integer index; - public Integer outputType; - public String name; - - public AudioOutputClusterOutputInfo(Integer index, Integer outputType, String name) { - this.index = index; - this.outputType = outputType; - this.name = name; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AudioOutputClusterOutputInfo {\n"); - output.append("\tindex: "); - output.append(index); - output.append("\n"); - output.append("\toutputType: "); - output.append(outputType); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class BridgedActionsClusterActionStruct { - public Integer actionID; - public String name; - public Integer type; - public Integer endpointListID; - public Integer supportedCommands; - public Integer status; - - public BridgedActionsClusterActionStruct( - Integer actionID, - String name, - Integer type, - Integer endpointListID, - Integer supportedCommands, - Integer status) { - this.actionID = actionID; - this.name = name; - this.type = type; - this.endpointListID = endpointListID; - this.supportedCommands = supportedCommands; - this.status = status; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedActionsClusterActionStruct {\n"); - output.append("\tactionID: "); - output.append(actionID); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tendpointListID: "); - output.append(endpointListID); - output.append("\n"); - output.append("\tsupportedCommands: "); - output.append(supportedCommands); - output.append("\n"); - output.append("\tstatus: "); - output.append(status); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class BridgedActionsClusterEndpointListStruct { - public Integer endpointListID; - public String name; - public Integer type; - public ArrayList endpoints; - - public BridgedActionsClusterEndpointListStruct( - Integer endpointListID, String name, Integer type, ArrayList endpoints) { - this.endpointListID = endpointListID; - this.name = name; - this.type = type; - this.endpoints = endpoints; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedActionsClusterEndpointListStruct {\n"); - output.append("\tendpointListID: "); - output.append(endpointListID); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tendpoints: "); - output.append(endpoints); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ChannelClusterChannelInfo { - public Integer majorNumber; - public Integer minorNumber; - public String name; - public String callSign; - public String affiliateCallSign; - - public ChannelClusterChannelInfo( - Integer majorNumber, - Integer minorNumber, - String name, - String callSign, - String affiliateCallSign) { - this.majorNumber = majorNumber; - this.minorNumber = minorNumber; - this.name = name; - this.callSign = callSign; - this.affiliateCallSign = affiliateCallSign; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ChannelClusterChannelInfo {\n"); - output.append("\tmajorNumber: "); - output.append(majorNumber); - output.append("\n"); - output.append("\tminorNumber: "); - output.append(minorNumber); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tcallSign: "); - output.append(callSign); - output.append("\n"); - output.append("\taffiliateCallSign: "); - output.append(affiliateCallSign); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ChannelClusterLineupInfo { - public String operatorName; - public String lineupName; - public String postalCode; - public Integer lineupInfoType; - - public ChannelClusterLineupInfo( - String operatorName, String lineupName, String postalCode, Integer lineupInfoType) { - this.operatorName = operatorName; - this.lineupName = lineupName; - this.postalCode = postalCode; - this.lineupInfoType = lineupInfoType; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ChannelClusterLineupInfo {\n"); - output.append("\toperatorName: "); - output.append(operatorName); - output.append("\n"); - output.append("\tlineupName: "); - output.append(lineupName); - output.append("\n"); - output.append("\tpostalCode: "); - output.append(postalCode); - output.append("\n"); - output.append("\tlineupInfoType: "); - output.append(lineupInfoType); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterDimension { - public Double width; - public Double height; - public Integer metric; - - public ContentLauncherClusterDimension(Double width, Double height, Integer metric) { - this.width = width; - this.height = height; - this.metric = metric; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterDimension {\n"); - output.append("\twidth: "); - output.append(width); - output.append("\n"); - output.append("\theight: "); - output.append(height); - output.append("\n"); - output.append("\tmetric: "); - output.append(metric); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterAdditionalInfo { - public String name; - public String value; - - public ContentLauncherClusterAdditionalInfo(String name, String value) { - this.name = name; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterAdditionalInfo {\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterParameter { - public Integer type; - public String value; - public ArrayList externalIDList; - - public ContentLauncherClusterParameter( - Integer type, - String value, - ArrayList externalIDList) { - this.type = type; - this.value = value; - this.externalIDList = externalIDList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterParameter {\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("\texternalIDList: "); - output.append(externalIDList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterContentSearch { - public ArrayList parameterList; - - public ContentLauncherClusterContentSearch( - ArrayList parameterList) { - this.parameterList = parameterList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterContentSearch {\n"); - output.append("\tparameterList: "); - output.append(parameterList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterStyleInformation { - public String imageUrl; - public String color; - public ChipStructs.ContentLauncherClusterDimension size; - - public ContentLauncherClusterStyleInformation( - String imageUrl, String color, ChipStructs.ContentLauncherClusterDimension size) { - this.imageUrl = imageUrl; - this.color = color; - this.size = size; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterStyleInformation {\n"); - output.append("\timageUrl: "); - output.append(imageUrl); - output.append("\n"); - output.append("\tcolor: "); - output.append(color); - output.append("\n"); - output.append("\tsize: "); - output.append(size); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterBrandingInformation { - public String providerName; - public ChipStructs.ContentLauncherClusterStyleInformation background; - public ChipStructs.ContentLauncherClusterStyleInformation logo; - public ChipStructs.ContentLauncherClusterStyleInformation progressBar; - public ChipStructs.ContentLauncherClusterStyleInformation splash; - public ChipStructs.ContentLauncherClusterStyleInformation waterMark; - - public ContentLauncherClusterBrandingInformation( - String providerName, - ChipStructs.ContentLauncherClusterStyleInformation background, - ChipStructs.ContentLauncherClusterStyleInformation logo, - ChipStructs.ContentLauncherClusterStyleInformation progressBar, - ChipStructs.ContentLauncherClusterStyleInformation splash, - ChipStructs.ContentLauncherClusterStyleInformation waterMark) { - this.providerName = providerName; - this.background = background; - this.logo = logo; - this.progressBar = progressBar; - this.splash = splash; - this.waterMark = waterMark; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterBrandingInformation {\n"); - output.append("\tproviderName: "); - output.append(providerName); - output.append("\n"); - output.append("\tbackground: "); - output.append(background); - output.append("\n"); - output.append("\tlogo: "); - output.append(logo); - output.append("\n"); - output.append("\tprogressBar: "); - output.append(progressBar); - output.append("\n"); - output.append("\tsplash: "); - output.append(splash); - output.append("\n"); - output.append("\twaterMark: "); - output.append(waterMark); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class DescriptorClusterDeviceType { - public Long type; - public Integer revision; - - public DescriptorClusterDeviceType(Long type, Integer revision) { - this.type = type; - this.revision = revision; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DescriptorClusterDeviceType {\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\trevision: "); - output.append(revision); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class DoorLockClusterDlCredential { - public Integer credentialType; - public Integer credentialIndex; - - public DoorLockClusterDlCredential(Integer credentialType, Integer credentialIndex) { - this.credentialType = credentialType; - this.credentialIndex = credentialIndex; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DoorLockClusterDlCredential {\n"); - output.append("\tcredentialType: "); - output.append(credentialType); - output.append("\n"); - output.append("\tcredentialIndex: "); - output.append(credentialIndex); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class FixedLabelClusterLabelStruct { - public String label; - public String value; - - public FixedLabelClusterLabelStruct(String label, String value) { - this.label = label; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("FixedLabelClusterLabelStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class GeneralCommissioningClusterBasicCommissioningInfoType { - public Long failSafeExpiryLengthMs; - - public GeneralCommissioningClusterBasicCommissioningInfoType(Long failSafeExpiryLengthMs) { - this.failSafeExpiryLengthMs = failSafeExpiryLengthMs; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GeneralCommissioningClusterBasicCommissioningInfoType {\n"); - output.append("\tfailSafeExpiryLengthMs: "); - output.append(failSafeExpiryLengthMs); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class GeneralDiagnosticsClusterNetworkInterfaceType { - public String name; - public Boolean fabricConnected; - public Boolean offPremiseServicesReachableIPv4; - public Boolean offPremiseServicesReachableIPv6; - public byte[] hardwareAddress; - public Integer type; - - public GeneralDiagnosticsClusterNetworkInterfaceType( - String name, - Boolean fabricConnected, - Boolean offPremiseServicesReachableIPv4, - Boolean offPremiseServicesReachableIPv6, - byte[] hardwareAddress, - Integer type) { - this.name = name; - this.fabricConnected = fabricConnected; - this.offPremiseServicesReachableIPv4 = offPremiseServicesReachableIPv4; - this.offPremiseServicesReachableIPv6 = offPremiseServicesReachableIPv6; - this.hardwareAddress = hardwareAddress; - this.type = type; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GeneralDiagnosticsClusterNetworkInterfaceType {\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tfabricConnected: "); - output.append(fabricConnected); - output.append("\n"); - output.append("\toffPremiseServicesReachableIPv4: "); - output.append(offPremiseServicesReachableIPv4); - output.append("\n"); - output.append("\toffPremiseServicesReachableIPv6: "); - output.append(offPremiseServicesReachableIPv6); - output.append("\n"); - output.append("\thardwareAddress: "); - output.append(Arrays.toString(hardwareAddress)); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class GroupKeyManagementClusterGroupInfo { - public Integer fabricIndex; - public Integer groupId; - public ArrayList endpoints; - public String groupName; - - public GroupKeyManagementClusterGroupInfo( - Integer fabricIndex, Integer groupId, ArrayList endpoints, String groupName) { - this.fabricIndex = fabricIndex; - this.groupId = groupId; - this.endpoints = endpoints; - this.groupName = groupName; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupInfo {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tgroupId: "); - output.append(groupId); - output.append("\n"); - output.append("\tendpoints: "); - output.append(endpoints); - output.append("\n"); - output.append("\tgroupName: "); - output.append(groupName); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class GroupKeyManagementClusterGroupKey { - public Integer fabricIndex; - public Integer groupId; - public Integer groupKeySetID; - - public GroupKeyManagementClusterGroupKey( - Integer fabricIndex, Integer groupId, Integer groupKeySetID) { - this.fabricIndex = fabricIndex; - this.groupId = groupId; - this.groupKeySetID = groupKeySetID; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupKey {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tgroupId: "); - output.append(groupId); - output.append("\n"); - output.append("\tgroupKeySetID: "); - output.append(groupKeySetID); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class GroupKeyManagementClusterGroupKeySet { - public Integer groupKeySetID; - public Integer securityPolicy; - public byte[] epochKey0; - public Long epochStartTime0; - public byte[] epochKey1; - public Long epochStartTime1; - public byte[] epochKey2; - public Long epochStartTime2; - - public GroupKeyManagementClusterGroupKeySet( - Integer groupKeySetID, - Integer securityPolicy, - byte[] epochKey0, - Long epochStartTime0, - byte[] epochKey1, - Long epochStartTime1, - byte[] epochKey2, - Long epochStartTime2) { - this.groupKeySetID = groupKeySetID; - this.securityPolicy = securityPolicy; - this.epochKey0 = epochKey0; - this.epochStartTime0 = epochStartTime0; - this.epochKey1 = epochKey1; - this.epochStartTime1 = epochStartTime1; - this.epochKey2 = epochKey2; - this.epochStartTime2 = epochStartTime2; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupKeySet {\n"); - output.append("\tgroupKeySetID: "); - output.append(groupKeySetID); - output.append("\n"); - output.append("\tsecurityPolicy: "); - output.append(securityPolicy); - output.append("\n"); - output.append("\tepochKey0: "); - output.append(Arrays.toString(epochKey0)); - output.append("\n"); - output.append("\tepochStartTime0: "); - output.append(epochStartTime0); - output.append("\n"); - output.append("\tepochKey1: "); - output.append(Arrays.toString(epochKey1)); - output.append("\n"); - output.append("\tepochStartTime1: "); - output.append(epochStartTime1); - output.append("\n"); - output.append("\tepochKey2: "); - output.append(Arrays.toString(epochKey2)); - output.append("\n"); - output.append("\tepochStartTime2: "); - output.append(epochStartTime2); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class MediaInputClusterInputInfo { - public Integer index; - public Integer inputType; - public String name; - public String description; - - public MediaInputClusterInputInfo( - Integer index, Integer inputType, String name, String description) { - this.index = index; - this.inputType = inputType; - this.name = name; - this.description = description; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("MediaInputClusterInputInfo {\n"); - output.append("\tindex: "); - output.append(index); - output.append("\n"); - output.append("\tinputType: "); - output.append(inputType); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tdescription: "); - output.append(description); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class MediaPlaybackClusterPlaybackPosition { - public Long updatedAt; - public Long position; - - public MediaPlaybackClusterPlaybackPosition(Long updatedAt, Long position) { - this.updatedAt = updatedAt; - this.position = position; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("MediaPlaybackClusterPlaybackPosition {\n"); - output.append("\tupdatedAt: "); - output.append(updatedAt); - output.append("\n"); - output.append("\tposition: "); - output.append(position); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ModeSelectClusterModeOptionStruct { - public String label; - public Integer mode; - public Long semanticTag; - - public ModeSelectClusterModeOptionStruct(String label, Integer mode, Long semanticTag) { - this.label = label; - this.mode = mode; - this.semanticTag = semanticTag; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ModeSelectClusterModeOptionStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tmode: "); - output.append(mode); - output.append("\n"); - output.append("\tsemanticTag: "); - output.append(semanticTag); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ModeSelectClusterSemanticTag { - public Integer mfgCode; - public Integer value; - - public ModeSelectClusterSemanticTag(Integer mfgCode, Integer value) { - this.mfgCode = mfgCode; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ModeSelectClusterSemanticTag {\n"); - output.append("\tmfgCode: "); - output.append(mfgCode); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class NetworkCommissioningClusterNetworkInfo { - public byte[] networkID; - public Boolean connected; - - public NetworkCommissioningClusterNetworkInfo(byte[] networkID, Boolean connected) { - this.networkID = networkID; - this.connected = connected; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterNetworkInfo {\n"); - output.append("\tnetworkID: "); - output.append(Arrays.toString(networkID)); - output.append("\n"); - output.append("\tconnected: "); - output.append(connected); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class NetworkCommissioningClusterThreadInterfaceScanResult { - public Long panId; - public Long extendedPanId; - public String networkName; - public Integer channel; - public Integer version; - public Long extendedAddress; - public Integer rssi; - public Integer lqi; - - public NetworkCommissioningClusterThreadInterfaceScanResult( - Long panId, - Long extendedPanId, - String networkName, - Integer channel, - Integer version, - Long extendedAddress, - Integer rssi, - Integer lqi) { - this.panId = panId; - this.extendedPanId = extendedPanId; - this.networkName = networkName; - this.channel = channel; - this.version = version; - this.extendedAddress = extendedAddress; - this.rssi = rssi; - this.lqi = lqi; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterThreadInterfaceScanResult {\n"); - output.append("\tpanId: "); - output.append(panId); - output.append("\n"); - output.append("\textendedPanId: "); - output.append(extendedPanId); - output.append("\n"); - output.append("\tnetworkName: "); - output.append(networkName); - output.append("\n"); - output.append("\tchannel: "); - output.append(channel); - output.append("\n"); - output.append("\tversion: "); - output.append(version); - output.append("\n"); - output.append("\textendedAddress: "); - output.append(extendedAddress); - output.append("\n"); - output.append("\trssi: "); - output.append(rssi); - output.append("\n"); - output.append("\tlqi: "); - output.append(lqi); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class NetworkCommissioningClusterWiFiInterfaceScanResult { - public Integer security; - public byte[] ssid; - public byte[] bssid; - public Integer channel; - public Integer wiFiBand; - public Integer rssi; - - public NetworkCommissioningClusterWiFiInterfaceScanResult( - Integer security, - byte[] ssid, - byte[] bssid, - Integer channel, - Integer wiFiBand, - Integer rssi) { - this.security = security; - this.ssid = ssid; - this.bssid = bssid; - this.channel = channel; - this.wiFiBand = wiFiBand; - this.rssi = rssi; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterWiFiInterfaceScanResult {\n"); - output.append("\tsecurity: "); - output.append(security); - output.append("\n"); - output.append("\tssid: "); - output.append(Arrays.toString(ssid)); - output.append("\n"); - output.append("\tbssid: "); - output.append(Arrays.toString(bssid)); - output.append("\n"); - output.append("\tchannel: "); - output.append(channel); - output.append("\n"); - output.append("\twiFiBand: "); - output.append(wiFiBand); - output.append("\n"); - output.append("\trssi: "); - output.append(rssi); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class OtaSoftwareUpdateRequestorClusterProviderLocation { - public Integer fabricIndex; - public Long providerNodeID; - public Integer endpoint; - - public OtaSoftwareUpdateRequestorClusterProviderLocation( - Integer fabricIndex, Long providerNodeID, Integer endpoint) { - this.fabricIndex = fabricIndex; - this.providerNodeID = providerNodeID; - this.endpoint = endpoint; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OtaSoftwareUpdateRequestorClusterProviderLocation {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tproviderNodeID: "); - output.append(providerNodeID); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class OperationalCredentialsClusterFabricDescriptor { - public Integer fabricIndex; - public byte[] rootPublicKey; - public Integer vendorId; - public Long fabricId; - public Long nodeId; - public String label; - - public OperationalCredentialsClusterFabricDescriptor( - Integer fabricIndex, - byte[] rootPublicKey, - Integer vendorId, - Long fabricId, - Long nodeId, - String label) { - this.fabricIndex = fabricIndex; - this.rootPublicKey = rootPublicKey; - this.vendorId = vendorId; - this.fabricId = fabricId; - this.nodeId = nodeId; - this.label = label; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OperationalCredentialsClusterFabricDescriptor {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\trootPublicKey: "); - output.append(Arrays.toString(rootPublicKey)); - output.append("\n"); - output.append("\tvendorId: "); - output.append(vendorId); - output.append("\n"); - output.append("\tfabricId: "); - output.append(fabricId); - output.append("\n"); - output.append("\tnodeId: "); - output.append(nodeId); - output.append("\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class OperationalCredentialsClusterNOCStruct { - public Integer fabricIndex; - public byte[] noc; - public @Nullable byte[] icac; - - public OperationalCredentialsClusterNOCStruct( - Integer fabricIndex, byte[] noc, @Nullable byte[] icac) { - this.fabricIndex = fabricIndex; - this.noc = noc; - this.icac = icac; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OperationalCredentialsClusterNOCStruct {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tnoc: "); - output.append(Arrays.toString(noc)); - output.append("\n"); - output.append("\ticac: "); - output.append(Arrays.toString(icac)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class PowerSourceClusterBatChargeFaultChangeType { - public ArrayList current; - public ArrayList previous; - - public PowerSourceClusterBatChargeFaultChangeType( - ArrayList current, ArrayList previous) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterBatChargeFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class PowerSourceClusterBatFaultChangeType { - public ArrayList current; - public ArrayList previous; - - public PowerSourceClusterBatFaultChangeType( - ArrayList current, ArrayList previous) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterBatFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class PowerSourceClusterWiredFaultChangeType { - public ArrayList current; - public ArrayList previous; - - public PowerSourceClusterWiredFaultChangeType( - ArrayList current, ArrayList previous) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterWiredFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ScenesClusterSceneExtensionFieldSet { - public Long clusterId; - public Integer length; - public Integer value; - - public ScenesClusterSceneExtensionFieldSet(Long clusterId, Integer length, Integer value) { - this.clusterId = clusterId; - this.length = length; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ScenesClusterSceneExtensionFieldSet {\n"); - output.append("\tclusterId: "); - output.append(clusterId); - output.append("\n"); - output.append("\tlength: "); - output.append(length); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class SoftwareDiagnosticsClusterSoftwareFaultStruct { - public Long id; - public String name; - public byte[] faultRecording; - - public SoftwareDiagnosticsClusterSoftwareFaultStruct( - Long id, String name, byte[] faultRecording) { - this.id = id; - this.name = name; - this.faultRecording = faultRecording; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SoftwareDiagnosticsClusterSoftwareFaultStruct {\n"); - output.append("\tid: "); - output.append(id); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tfaultRecording: "); - output.append(Arrays.toString(faultRecording)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class SoftwareDiagnosticsClusterThreadMetrics { - public Long id; - public String name; - public Long stackFreeCurrent; - public Long stackFreeMinimum; - public Long stackSize; - - public SoftwareDiagnosticsClusterThreadMetrics( - Long id, String name, Long stackFreeCurrent, Long stackFreeMinimum, Long stackSize) { - this.id = id; - this.name = name; - this.stackFreeCurrent = stackFreeCurrent; - this.stackFreeMinimum = stackFreeMinimum; - this.stackSize = stackSize; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SoftwareDiagnosticsClusterThreadMetrics {\n"); - output.append("\tid: "); - output.append(id); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tstackFreeCurrent: "); - output.append(stackFreeCurrent); - output.append("\n"); - output.append("\tstackFreeMinimum: "); - output.append(stackFreeMinimum); - output.append("\n"); - output.append("\tstackSize: "); - output.append(stackSize); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TargetNavigatorClusterTargetInfo { - public Integer identifier; - public String name; - - public TargetNavigatorClusterTargetInfo(Integer identifier, String name) { - this.identifier = identifier; - this.name = name; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TargetNavigatorClusterTargetInfo {\n"); - output.append("\tidentifier: "); - output.append(identifier); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterSimpleStruct { - public Integer a; - public Boolean b; - public Integer c; - public byte[] d; - public String e; - public Integer f; - public Float g; - public Double h; - - public TestClusterClusterSimpleStruct( - Integer a, Boolean b, Integer c, byte[] d, String e, Integer f, Float g, Double h) { - this.a = a; - this.b = b; - this.c = c; - this.d = d; - this.e = e; - this.f = f; - this.g = g; - this.h = h; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterSimpleStruct {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("\td: "); - output.append(Arrays.toString(d)); - output.append("\n"); - output.append("\te: "); - output.append(e); - output.append("\n"); - output.append("\tf: "); - output.append(f); - output.append("\n"); - output.append("\tg: "); - output.append(g); - output.append("\n"); - output.append("\th: "); - output.append(h); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterNullablesAndOptionalsStruct { - public @Nullable Integer nullableInt; - public Optional optionalInt; - public @Nullable Optional nullableOptionalInt; - public @Nullable String nullableString; - public Optional optionalString; - public @Nullable Optional nullableOptionalString; - public @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct; - public Optional optionalStruct; - public @Nullable Optional nullableOptionalStruct; - public @Nullable ArrayList nullableList; - public Optional> optionalList; - public @Nullable Optional> nullableOptionalList; - - public TestClusterClusterNullablesAndOptionalsStruct( - @Nullable Integer nullableInt, - Optional optionalInt, - @Nullable Optional nullableOptionalInt, - @Nullable String nullableString, - Optional optionalString, - @Nullable Optional nullableOptionalString, - @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct, - Optional optionalStruct, - @Nullable Optional nullableOptionalStruct, - @Nullable ArrayList nullableList, - Optional> optionalList, - @Nullable Optional> nullableOptionalList) { - this.nullableInt = nullableInt; - this.optionalInt = optionalInt; - this.nullableOptionalInt = nullableOptionalInt; - this.nullableString = nullableString; - this.optionalString = optionalString; - this.nullableOptionalString = nullableOptionalString; - this.nullableStruct = nullableStruct; - this.optionalStruct = optionalStruct; - this.nullableOptionalStruct = nullableOptionalStruct; - this.nullableList = nullableList; - this.optionalList = optionalList; - this.nullableOptionalList = nullableOptionalList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNullablesAndOptionalsStruct {\n"); - output.append("\tnullableInt: "); - output.append(nullableInt); - output.append("\n"); - output.append("\toptionalInt: "); - output.append(optionalInt); - output.append("\n"); - output.append("\tnullableOptionalInt: "); - output.append(nullableOptionalInt); - output.append("\n"); - output.append("\tnullableString: "); - output.append(nullableString); - output.append("\n"); - output.append("\toptionalString: "); - output.append(optionalString); - output.append("\n"); - output.append("\tnullableOptionalString: "); - output.append(nullableOptionalString); - output.append("\n"); - output.append("\tnullableStruct: "); - output.append(nullableStruct); - output.append("\n"); - output.append("\toptionalStruct: "); - output.append(optionalStruct); - output.append("\n"); - output.append("\tnullableOptionalStruct: "); - output.append(nullableOptionalStruct); - output.append("\n"); - output.append("\tnullableList: "); - output.append(nullableList); - output.append("\n"); - output.append("\toptionalList: "); - output.append(optionalList); - output.append("\n"); - output.append("\tnullableOptionalList: "); - output.append(nullableOptionalList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterNestedStruct { - public Integer a; - public Boolean b; - public ChipStructs.TestClusterClusterSimpleStruct c; - - public TestClusterClusterNestedStruct( - Integer a, Boolean b, ChipStructs.TestClusterClusterSimpleStruct c) { - this.a = a; - this.b = b; - this.c = c; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNestedStruct {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterNestedStructList { - public Integer a; - public Boolean b; - public ChipStructs.TestClusterClusterSimpleStruct c; - public ArrayList d; - public ArrayList e; - public ArrayList f; - public ArrayList g; - - public TestClusterClusterNestedStructList( - Integer a, - Boolean b, - ChipStructs.TestClusterClusterSimpleStruct c, - ArrayList d, - ArrayList e, - ArrayList f, - ArrayList g) { - this.a = a; - this.b = b; - this.c = c; - this.d = d; - this.e = e; - this.f = f; - this.g = g; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNestedStructList {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("\td: "); - output.append(d); - output.append("\n"); - output.append("\te: "); - output.append(e); - output.append("\n"); - output.append("\tf: "); - output.append(f); - output.append("\n"); - output.append("\tg: "); - output.append(g); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterDoubleNestedStructList { - public ArrayList a; - - public TestClusterClusterDoubleNestedStructList( - ArrayList a) { - this.a = a; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterDoubleNestedStructList {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterTestFabricScoped { - public Integer fabricIndex; - - public TestClusterClusterTestFabricScoped(Integer fabricIndex) { - this.fabricIndex = fabricIndex; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterTestFabricScoped {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterTestListStructOctet { - public Long fabricIndex; - public byte[] operationalCert; - - public TestClusterClusterTestListStructOctet(Long fabricIndex, byte[] operationalCert) { - this.fabricIndex = fabricIndex; - this.operationalCert = operationalCert; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterTestListStructOctet {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\toperationalCert: "); - output.append(Arrays.toString(operationalCert)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ThreadNetworkDiagnosticsClusterNeighborTable { - public Long extAddress; - public Long age; - public Integer rloc16; - public Long linkFrameCounter; - public Long mleFrameCounter; - public Integer lqi; - public Integer averageRssi; - public Integer lastRssi; - public Integer frameErrorRate; - public Integer messageErrorRate; - public Boolean rxOnWhenIdle; - public Boolean fullThreadDevice; - public Boolean fullNetworkData; - public Boolean isChild; - - public ThreadNetworkDiagnosticsClusterNeighborTable( - Long extAddress, - Long age, - Integer rloc16, - Long linkFrameCounter, - Long mleFrameCounter, - Integer lqi, - Integer averageRssi, - Integer lastRssi, - Integer frameErrorRate, - Integer messageErrorRate, - Boolean rxOnWhenIdle, - Boolean fullThreadDevice, - Boolean fullNetworkData, - Boolean isChild) { - this.extAddress = extAddress; - this.age = age; - this.rloc16 = rloc16; - this.linkFrameCounter = linkFrameCounter; - this.mleFrameCounter = mleFrameCounter; - this.lqi = lqi; - this.averageRssi = averageRssi; - this.lastRssi = lastRssi; - this.frameErrorRate = frameErrorRate; - this.messageErrorRate = messageErrorRate; - this.rxOnWhenIdle = rxOnWhenIdle; - this.fullThreadDevice = fullThreadDevice; - this.fullNetworkData = fullNetworkData; - this.isChild = isChild; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterNeighborTable {\n"); - output.append("\textAddress: "); - output.append(extAddress); - output.append("\n"); - output.append("\tage: "); - output.append(age); - output.append("\n"); - output.append("\trloc16: "); - output.append(rloc16); - output.append("\n"); - output.append("\tlinkFrameCounter: "); - output.append(linkFrameCounter); - output.append("\n"); - output.append("\tmleFrameCounter: "); - output.append(mleFrameCounter); - output.append("\n"); - output.append("\tlqi: "); - output.append(lqi); - output.append("\n"); - output.append("\taverageRssi: "); - output.append(averageRssi); - output.append("\n"); - output.append("\tlastRssi: "); - output.append(lastRssi); - output.append("\n"); - output.append("\tframeErrorRate: "); - output.append(frameErrorRate); - output.append("\n"); - output.append("\tmessageErrorRate: "); - output.append(messageErrorRate); - output.append("\n"); - output.append("\trxOnWhenIdle: "); - output.append(rxOnWhenIdle); - output.append("\n"); - output.append("\tfullThreadDevice: "); - output.append(fullThreadDevice); - output.append("\n"); - output.append("\tfullNetworkData: "); - output.append(fullNetworkData); - output.append("\n"); - output.append("\tisChild: "); - output.append(isChild); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ThreadNetworkDiagnosticsClusterOperationalDatasetComponents { - public Boolean activeTimestampPresent; - public Boolean pendingTimestampPresent; - public Boolean masterKeyPresent; - public Boolean networkNamePresent; - public Boolean extendedPanIdPresent; - public Boolean meshLocalPrefixPresent; - public Boolean delayPresent; - public Boolean panIdPresent; - public Boolean channelPresent; - public Boolean pskcPresent; - public Boolean securityPolicyPresent; - public Boolean channelMaskPresent; - - public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents( - Boolean activeTimestampPresent, - Boolean pendingTimestampPresent, - Boolean masterKeyPresent, - Boolean networkNamePresent, - Boolean extendedPanIdPresent, - Boolean meshLocalPrefixPresent, - Boolean delayPresent, - Boolean panIdPresent, - Boolean channelPresent, - Boolean pskcPresent, - Boolean securityPolicyPresent, - Boolean channelMaskPresent) { - this.activeTimestampPresent = activeTimestampPresent; - this.pendingTimestampPresent = pendingTimestampPresent; - this.masterKeyPresent = masterKeyPresent; - this.networkNamePresent = networkNamePresent; - this.extendedPanIdPresent = extendedPanIdPresent; - this.meshLocalPrefixPresent = meshLocalPrefixPresent; - this.delayPresent = delayPresent; - this.panIdPresent = panIdPresent; - this.channelPresent = channelPresent; - this.pskcPresent = pskcPresent; - this.securityPolicyPresent = securityPolicyPresent; - this.channelMaskPresent = channelMaskPresent; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterOperationalDatasetComponents {\n"); - output.append("\tactiveTimestampPresent: "); - output.append(activeTimestampPresent); - output.append("\n"); - output.append("\tpendingTimestampPresent: "); - output.append(pendingTimestampPresent); - output.append("\n"); - output.append("\tmasterKeyPresent: "); - output.append(masterKeyPresent); - output.append("\n"); - output.append("\tnetworkNamePresent: "); - output.append(networkNamePresent); - output.append("\n"); - output.append("\textendedPanIdPresent: "); - output.append(extendedPanIdPresent); - output.append("\n"); - output.append("\tmeshLocalPrefixPresent: "); - output.append(meshLocalPrefixPresent); - output.append("\n"); - output.append("\tdelayPresent: "); - output.append(delayPresent); - output.append("\n"); - output.append("\tpanIdPresent: "); - output.append(panIdPresent); - output.append("\n"); - output.append("\tchannelPresent: "); - output.append(channelPresent); - output.append("\n"); - output.append("\tpskcPresent: "); - output.append(pskcPresent); - output.append("\n"); - output.append("\tsecurityPolicyPresent: "); - output.append(securityPolicyPresent); - output.append("\n"); - output.append("\tchannelMaskPresent: "); - output.append(channelMaskPresent); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ThreadNetworkDiagnosticsClusterRouteTable { - public Long extAddress; - public Integer rloc16; - public Integer routerId; - public Integer nextHop; - public Integer pathCost; - public Integer LQIIn; - public Integer LQIOut; - public Integer age; - public Boolean allocated; - public Boolean linkEstablished; - - public ThreadNetworkDiagnosticsClusterRouteTable( - Long extAddress, - Integer rloc16, - Integer routerId, - Integer nextHop, - Integer pathCost, - Integer LQIIn, - Integer LQIOut, - Integer age, - Boolean allocated, - Boolean linkEstablished) { - this.extAddress = extAddress; - this.rloc16 = rloc16; - this.routerId = routerId; - this.nextHop = nextHop; - this.pathCost = pathCost; - this.LQIIn = LQIIn; - this.LQIOut = LQIOut; - this.age = age; - this.allocated = allocated; - this.linkEstablished = linkEstablished; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterRouteTable {\n"); - output.append("\textAddress: "); - output.append(extAddress); - output.append("\n"); - output.append("\trloc16: "); - output.append(rloc16); - output.append("\n"); - output.append("\trouterId: "); - output.append(routerId); - output.append("\n"); - output.append("\tnextHop: "); - output.append(nextHop); - output.append("\n"); - output.append("\tpathCost: "); - output.append(pathCost); - output.append("\n"); - output.append("\tLQIIn: "); - output.append(LQIIn); - output.append("\n"); - output.append("\tLQIOut: "); - output.append(LQIOut); - output.append("\n"); - output.append("\tage: "); - output.append(age); - output.append("\n"); - output.append("\tallocated: "); - output.append(allocated); - output.append("\n"); - output.append("\tlinkEstablished: "); - output.append(linkEstablished); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ThreadNetworkDiagnosticsClusterSecurityPolicy { - public Integer rotationTime; - public Integer flags; - - public ThreadNetworkDiagnosticsClusterSecurityPolicy(Integer rotationTime, Integer flags) { - this.rotationTime = rotationTime; - this.flags = flags; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterSecurityPolicy {\n"); - output.append("\trotationTime: "); - output.append(rotationTime); - output.append("\n"); - output.append("\tflags: "); - output.append(flags); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class UserLabelClusterLabelStruct { - public String label; - public String value; - - public UserLabelClusterLabelStruct(String label, String value) { - this.label = label; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("UserLabelClusterLabelStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } +public static class AccessControlClusterTarget { +public @Nullable Long cluster; +public @Nullable Integer endpoint; +public @Nullable Long deviceType; + + public AccessControlClusterTarget( + @Nullable Long cluster + , @Nullable Integer endpoint + , @Nullable Long deviceType + ) { + this.cluster = cluster; + this.endpoint = endpoint; + this.deviceType = deviceType; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterTarget {\n"); + output.append("\tcluster: "); + output.append(cluster); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("\tdeviceType: "); + output.append(deviceType); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class AccessControlClusterAccessControlEntry { +public Integer fabricIndex; +public Integer privilege; +public Integer authMode; +public @Nullable ArrayList subjects; +public @Nullable ArrayList targets; + + public AccessControlClusterAccessControlEntry( + Integer fabricIndex + , Integer privilege + , Integer authMode + , @Nullable ArrayList subjects + , @Nullable ArrayList targets + ) { + this.fabricIndex = fabricIndex; + this.privilege = privilege; + this.authMode = authMode; + this.subjects = subjects; + this.targets = targets; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterAccessControlEntry {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tprivilege: "); + output.append(privilege); + output.append("\n"); + output.append("\tauthMode: "); + output.append(authMode); + output.append("\n"); + output.append("\tsubjects: "); + output.append(subjects); + output.append("\n"); + output.append("\ttargets: "); + output.append(targets); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class AccessControlClusterExtensionEntry { +public Integer fabricIndex; +public byte[] data; + + public AccessControlClusterExtensionEntry( + Integer fabricIndex + , byte[] data + ) { + this.fabricIndex = fabricIndex; + this.data = data; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterExtensionEntry {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tdata: "); + output.append(Arrays.toString(data)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ApplicationBasicClusterApplicationBasicApplication { +public Integer catalogVendorId; +public String applicationId; + + public ApplicationBasicClusterApplicationBasicApplication( + Integer catalogVendorId + , String applicationId + ) { + this.catalogVendorId = catalogVendorId; + this.applicationId = applicationId; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationBasicClusterApplicationBasicApplication {\n"); + output.append("\tcatalogVendorId: "); + output.append(catalogVendorId); + output.append("\n"); + output.append("\tapplicationId: "); + output.append(applicationId); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ApplicationLauncherClusterApplicationLauncherApplication { +public Integer catalogVendorId; +public String applicationId; + + public ApplicationLauncherClusterApplicationLauncherApplication( + Integer catalogVendorId + , String applicationId + ) { + this.catalogVendorId = catalogVendorId; + this.applicationId = applicationId; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationLauncherClusterApplicationLauncherApplication {\n"); + output.append("\tcatalogVendorId: "); + output.append(catalogVendorId); + output.append("\n"); + output.append("\tapplicationId: "); + output.append(applicationId); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ApplicationLauncherClusterApplicationEP { +public ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application; +public String endpoint; + + public ApplicationLauncherClusterApplicationEP( + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , String endpoint + ) { + this.application = application; + this.endpoint = endpoint; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationLauncherClusterApplicationEP {\n"); + output.append("\tapplication: "); + output.append(application); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class AudioOutputClusterOutputInfo { +public Integer index; +public Integer outputType; +public String name; + + public AudioOutputClusterOutputInfo( + Integer index + , Integer outputType + , String name + ) { + this.index = index; + this.outputType = outputType; + this.name = name; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AudioOutputClusterOutputInfo {\n"); + output.append("\tindex: "); + output.append(index); + output.append("\n"); + output.append("\toutputType: "); + output.append(outputType); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class BridgedActionsClusterActionStruct { +public Integer actionID; +public String name; +public Integer type; +public Integer endpointListID; +public Integer supportedCommands; +public Integer status; + + public BridgedActionsClusterActionStruct( + Integer actionID + , String name + , Integer type + , Integer endpointListID + , Integer supportedCommands + , Integer status + ) { + this.actionID = actionID; + this.name = name; + this.type = type; + this.endpointListID = endpointListID; + this.supportedCommands = supportedCommands; + this.status = status; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedActionsClusterActionStruct {\n"); + output.append("\tactionID: "); + output.append(actionID); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tendpointListID: "); + output.append(endpointListID); + output.append("\n"); + output.append("\tsupportedCommands: "); + output.append(supportedCommands); + output.append("\n"); + output.append("\tstatus: "); + output.append(status); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class BridgedActionsClusterEndpointListStruct { +public Integer endpointListID; +public String name; +public Integer type; +public ArrayList endpoints; + + public BridgedActionsClusterEndpointListStruct( + Integer endpointListID + , String name + , Integer type + , ArrayList endpoints + ) { + this.endpointListID = endpointListID; + this.name = name; + this.type = type; + this.endpoints = endpoints; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedActionsClusterEndpointListStruct {\n"); + output.append("\tendpointListID: "); + output.append(endpointListID); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tendpoints: "); + output.append(endpoints); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ChannelClusterChannelInfo { +public Integer majorNumber; +public Integer minorNumber; +public String name; +public String callSign; +public String affiliateCallSign; + + public ChannelClusterChannelInfo( + Integer majorNumber + , Integer minorNumber + , String name + , String callSign + , String affiliateCallSign + ) { + this.majorNumber = majorNumber; + this.minorNumber = minorNumber; + this.name = name; + this.callSign = callSign; + this.affiliateCallSign = affiliateCallSign; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ChannelClusterChannelInfo {\n"); + output.append("\tmajorNumber: "); + output.append(majorNumber); + output.append("\n"); + output.append("\tminorNumber: "); + output.append(minorNumber); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tcallSign: "); + output.append(callSign); + output.append("\n"); + output.append("\taffiliateCallSign: "); + output.append(affiliateCallSign); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ChannelClusterLineupInfo { +public String operatorName; +public String lineupName; +public String postalCode; +public Integer lineupInfoType; + + public ChannelClusterLineupInfo( + String operatorName + , String lineupName + , String postalCode + , Integer lineupInfoType + ) { + this.operatorName = operatorName; + this.lineupName = lineupName; + this.postalCode = postalCode; + this.lineupInfoType = lineupInfoType; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ChannelClusterLineupInfo {\n"); + output.append("\toperatorName: "); + output.append(operatorName); + output.append("\n"); + output.append("\tlineupName: "); + output.append(lineupName); + output.append("\n"); + output.append("\tpostalCode: "); + output.append(postalCode); + output.append("\n"); + output.append("\tlineupInfoType: "); + output.append(lineupInfoType); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterDimension { +public Double width; +public Double height; +public Integer metric; + + public ContentLauncherClusterDimension( + Double width + , Double height + , Integer metric + ) { + this.width = width; + this.height = height; + this.metric = metric; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterDimension {\n"); + output.append("\twidth: "); + output.append(width); + output.append("\n"); + output.append("\theight: "); + output.append(height); + output.append("\n"); + output.append("\tmetric: "); + output.append(metric); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterAdditionalInfo { +public String name; +public String value; + + public ContentLauncherClusterAdditionalInfo( + String name + , String value + ) { + this.name = name; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterAdditionalInfo {\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterParameter { +public Integer type; +public String value; +public ArrayList externalIDList; + + public ContentLauncherClusterParameter( + Integer type + , String value + , ArrayList externalIDList + ) { + this.type = type; + this.value = value; + this.externalIDList = externalIDList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterParameter {\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("\texternalIDList: "); + output.append(externalIDList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterContentSearch { +public ArrayList parameterList; + + public ContentLauncherClusterContentSearch( + ArrayList parameterList + ) { + this.parameterList = parameterList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterContentSearch {\n"); + output.append("\tparameterList: "); + output.append(parameterList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterStyleInformation { +public String imageUrl; +public String color; +public ChipStructs.ContentLauncherClusterDimension size; + + public ContentLauncherClusterStyleInformation( + String imageUrl + , String color + , ChipStructs.ContentLauncherClusterDimension size + ) { + this.imageUrl = imageUrl; + this.color = color; + this.size = size; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterStyleInformation {\n"); + output.append("\timageUrl: "); + output.append(imageUrl); + output.append("\n"); + output.append("\tcolor: "); + output.append(color); + output.append("\n"); + output.append("\tsize: "); + output.append(size); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterBrandingInformation { +public String providerName; +public ChipStructs.ContentLauncherClusterStyleInformation background; +public ChipStructs.ContentLauncherClusterStyleInformation logo; +public ChipStructs.ContentLauncherClusterStyleInformation progressBar; +public ChipStructs.ContentLauncherClusterStyleInformation splash; +public ChipStructs.ContentLauncherClusterStyleInformation waterMark; + + public ContentLauncherClusterBrandingInformation( + String providerName + , ChipStructs.ContentLauncherClusterStyleInformation background + , ChipStructs.ContentLauncherClusterStyleInformation logo + , ChipStructs.ContentLauncherClusterStyleInformation progressBar + , ChipStructs.ContentLauncherClusterStyleInformation splash + , ChipStructs.ContentLauncherClusterStyleInformation waterMark + ) { + this.providerName = providerName; + this.background = background; + this.logo = logo; + this.progressBar = progressBar; + this.splash = splash; + this.waterMark = waterMark; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterBrandingInformation {\n"); + output.append("\tproviderName: "); + output.append(providerName); + output.append("\n"); + output.append("\tbackground: "); + output.append(background); + output.append("\n"); + output.append("\tlogo: "); + output.append(logo); + output.append("\n"); + output.append("\tprogressBar: "); + output.append(progressBar); + output.append("\n"); + output.append("\tsplash: "); + output.append(splash); + output.append("\n"); + output.append("\twaterMark: "); + output.append(waterMark); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class DescriptorClusterDeviceType { +public Long type; +public Integer revision; + + public DescriptorClusterDeviceType( + Long type + , Integer revision + ) { + this.type = type; + this.revision = revision; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DescriptorClusterDeviceType {\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\trevision: "); + output.append(revision); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class DoorLockClusterDlCredential { +public Integer credentialType; +public Integer credentialIndex; + + public DoorLockClusterDlCredential( + Integer credentialType + , Integer credentialIndex + ) { + this.credentialType = credentialType; + this.credentialIndex = credentialIndex; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DoorLockClusterDlCredential {\n"); + output.append("\tcredentialType: "); + output.append(credentialType); + output.append("\n"); + output.append("\tcredentialIndex: "); + output.append(credentialIndex); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class FixedLabelClusterLabelStruct { +public String label; +public String value; + + public FixedLabelClusterLabelStruct( + String label + , String value + ) { + this.label = label; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("FixedLabelClusterLabelStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class GeneralCommissioningClusterBasicCommissioningInfoType { +public Long failSafeExpiryLengthMs; + + public GeneralCommissioningClusterBasicCommissioningInfoType( + Long failSafeExpiryLengthMs + ) { + this.failSafeExpiryLengthMs = failSafeExpiryLengthMs; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GeneralCommissioningClusterBasicCommissioningInfoType {\n"); + output.append("\tfailSafeExpiryLengthMs: "); + output.append(failSafeExpiryLengthMs); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class GeneralDiagnosticsClusterNetworkInterfaceType { +public String name; +public Boolean fabricConnected; +public Boolean offPremiseServicesReachableIPv4; +public Boolean offPremiseServicesReachableIPv6; +public byte[] hardwareAddress; +public Integer type; + + public GeneralDiagnosticsClusterNetworkInterfaceType( + String name + , Boolean fabricConnected + , Boolean offPremiseServicesReachableIPv4 + , Boolean offPremiseServicesReachableIPv6 + , byte[] hardwareAddress + , Integer type + ) { + this.name = name; + this.fabricConnected = fabricConnected; + this.offPremiseServicesReachableIPv4 = offPremiseServicesReachableIPv4; + this.offPremiseServicesReachableIPv6 = offPremiseServicesReachableIPv6; + this.hardwareAddress = hardwareAddress; + this.type = type; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GeneralDiagnosticsClusterNetworkInterfaceType {\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tfabricConnected: "); + output.append(fabricConnected); + output.append("\n"); + output.append("\toffPremiseServicesReachableIPv4: "); + output.append(offPremiseServicesReachableIPv4); + output.append("\n"); + output.append("\toffPremiseServicesReachableIPv6: "); + output.append(offPremiseServicesReachableIPv6); + output.append("\n"); + output.append("\thardwareAddress: "); + output.append(Arrays.toString(hardwareAddress)); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class GroupKeyManagementClusterGroupInfo { +public Integer fabricIndex; +public Integer groupId; +public ArrayList endpoints; +public String groupName; + + public GroupKeyManagementClusterGroupInfo( + Integer fabricIndex + , Integer groupId + , ArrayList endpoints + , String groupName + ) { + this.fabricIndex = fabricIndex; + this.groupId = groupId; + this.endpoints = endpoints; + this.groupName = groupName; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupInfo {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tgroupId: "); + output.append(groupId); + output.append("\n"); + output.append("\tendpoints: "); + output.append(endpoints); + output.append("\n"); + output.append("\tgroupName: "); + output.append(groupName); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class GroupKeyManagementClusterGroupKey { +public Integer fabricIndex; +public Integer groupId; +public Integer groupKeySetID; + + public GroupKeyManagementClusterGroupKey( + Integer fabricIndex + , Integer groupId + , Integer groupKeySetID + ) { + this.fabricIndex = fabricIndex; + this.groupId = groupId; + this.groupKeySetID = groupKeySetID; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupKey {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tgroupId: "); + output.append(groupId); + output.append("\n"); + output.append("\tgroupKeySetID: "); + output.append(groupKeySetID); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class GroupKeyManagementClusterGroupKeySet { +public Integer groupKeySetID; +public Integer securityPolicy; +public byte[] epochKey0; +public Long epochStartTime0; +public byte[] epochKey1; +public Long epochStartTime1; +public byte[] epochKey2; +public Long epochStartTime2; + + public GroupKeyManagementClusterGroupKeySet( + Integer groupKeySetID + , Integer securityPolicy + , byte[] epochKey0 + , Long epochStartTime0 + , byte[] epochKey1 + , Long epochStartTime1 + , byte[] epochKey2 + , Long epochStartTime2 + ) { + this.groupKeySetID = groupKeySetID; + this.securityPolicy = securityPolicy; + this.epochKey0 = epochKey0; + this.epochStartTime0 = epochStartTime0; + this.epochKey1 = epochKey1; + this.epochStartTime1 = epochStartTime1; + this.epochKey2 = epochKey2; + this.epochStartTime2 = epochStartTime2; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupKeySet {\n"); + output.append("\tgroupKeySetID: "); + output.append(groupKeySetID); + output.append("\n"); + output.append("\tsecurityPolicy: "); + output.append(securityPolicy); + output.append("\n"); + output.append("\tepochKey0: "); + output.append(Arrays.toString(epochKey0)); + output.append("\n"); + output.append("\tepochStartTime0: "); + output.append(epochStartTime0); + output.append("\n"); + output.append("\tepochKey1: "); + output.append(Arrays.toString(epochKey1)); + output.append("\n"); + output.append("\tepochStartTime1: "); + output.append(epochStartTime1); + output.append("\n"); + output.append("\tepochKey2: "); + output.append(Arrays.toString(epochKey2)); + output.append("\n"); + output.append("\tepochStartTime2: "); + output.append(epochStartTime2); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class MediaInputClusterInputInfo { +public Integer index; +public Integer inputType; +public String name; +public String description; + + public MediaInputClusterInputInfo( + Integer index + , Integer inputType + , String name + , String description + ) { + this.index = index; + this.inputType = inputType; + this.name = name; + this.description = description; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("MediaInputClusterInputInfo {\n"); + output.append("\tindex: "); + output.append(index); + output.append("\n"); + output.append("\tinputType: "); + output.append(inputType); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tdescription: "); + output.append(description); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class MediaPlaybackClusterPlaybackPosition { +public Long updatedAt; +public Long position; + + public MediaPlaybackClusterPlaybackPosition( + Long updatedAt + , Long position + ) { + this.updatedAt = updatedAt; + this.position = position; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("MediaPlaybackClusterPlaybackPosition {\n"); + output.append("\tupdatedAt: "); + output.append(updatedAt); + output.append("\n"); + output.append("\tposition: "); + output.append(position); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ModeSelectClusterModeOptionStruct { +public String label; +public Integer mode; +public Long semanticTag; + + public ModeSelectClusterModeOptionStruct( + String label + , Integer mode + , Long semanticTag + ) { + this.label = label; + this.mode = mode; + this.semanticTag = semanticTag; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ModeSelectClusterModeOptionStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tmode: "); + output.append(mode); + output.append("\n"); + output.append("\tsemanticTag: "); + output.append(semanticTag); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ModeSelectClusterSemanticTag { +public Integer mfgCode; +public Integer value; + + public ModeSelectClusterSemanticTag( + Integer mfgCode + , Integer value + ) { + this.mfgCode = mfgCode; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ModeSelectClusterSemanticTag {\n"); + output.append("\tmfgCode: "); + output.append(mfgCode); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class NetworkCommissioningClusterNetworkInfo { +public byte[] networkID; +public Boolean connected; + + public NetworkCommissioningClusterNetworkInfo( + byte[] networkID + , Boolean connected + ) { + this.networkID = networkID; + this.connected = connected; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterNetworkInfo {\n"); + output.append("\tnetworkID: "); + output.append(Arrays.toString(networkID)); + output.append("\n"); + output.append("\tconnected: "); + output.append(connected); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class NetworkCommissioningClusterThreadInterfaceScanResult { +public Long panId; +public Long extendedPanId; +public String networkName; +public Integer channel; +public Integer version; +public Long extendedAddress; +public Integer rssi; +public Integer lqi; + + public NetworkCommissioningClusterThreadInterfaceScanResult( + Long panId + , Long extendedPanId + , String networkName + , Integer channel + , Integer version + , Long extendedAddress + , Integer rssi + , Integer lqi + ) { + this.panId = panId; + this.extendedPanId = extendedPanId; + this.networkName = networkName; + this.channel = channel; + this.version = version; + this.extendedAddress = extendedAddress; + this.rssi = rssi; + this.lqi = lqi; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterThreadInterfaceScanResult {\n"); + output.append("\tpanId: "); + output.append(panId); + output.append("\n"); + output.append("\textendedPanId: "); + output.append(extendedPanId); + output.append("\n"); + output.append("\tnetworkName: "); + output.append(networkName); + output.append("\n"); + output.append("\tchannel: "); + output.append(channel); + output.append("\n"); + output.append("\tversion: "); + output.append(version); + output.append("\n"); + output.append("\textendedAddress: "); + output.append(extendedAddress); + output.append("\n"); + output.append("\trssi: "); + output.append(rssi); + output.append("\n"); + output.append("\tlqi: "); + output.append(lqi); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class NetworkCommissioningClusterWiFiInterfaceScanResult { +public Integer security; +public byte[] ssid; +public byte[] bssid; +public Integer channel; +public Integer wiFiBand; +public Integer rssi; + + public NetworkCommissioningClusterWiFiInterfaceScanResult( + Integer security + , byte[] ssid + , byte[] bssid + , Integer channel + , Integer wiFiBand + , Integer rssi + ) { + this.security = security; + this.ssid = ssid; + this.bssid = bssid; + this.channel = channel; + this.wiFiBand = wiFiBand; + this.rssi = rssi; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterWiFiInterfaceScanResult {\n"); + output.append("\tsecurity: "); + output.append(security); + output.append("\n"); + output.append("\tssid: "); + output.append(Arrays.toString(ssid)); + output.append("\n"); + output.append("\tbssid: "); + output.append(Arrays.toString(bssid)); + output.append("\n"); + output.append("\tchannel: "); + output.append(channel); + output.append("\n"); + output.append("\twiFiBand: "); + output.append(wiFiBand); + output.append("\n"); + output.append("\trssi: "); + output.append(rssi); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class OtaSoftwareUpdateRequestorClusterProviderLocation { +public Integer fabricIndex; +public Long providerNodeID; +public Integer endpoint; + + public OtaSoftwareUpdateRequestorClusterProviderLocation( + Integer fabricIndex + , Long providerNodeID + , Integer endpoint + ) { + this.fabricIndex = fabricIndex; + this.providerNodeID = providerNodeID; + this.endpoint = endpoint; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OtaSoftwareUpdateRequestorClusterProviderLocation {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tproviderNodeID: "); + output.append(providerNodeID); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class OperationalCredentialsClusterFabricDescriptor { +public Integer fabricIndex; +public byte[] rootPublicKey; +public Integer vendorId; +public Long fabricId; +public Long nodeId; +public String label; + + public OperationalCredentialsClusterFabricDescriptor( + Integer fabricIndex + , byte[] rootPublicKey + , Integer vendorId + , Long fabricId + , Long nodeId + , String label + ) { + this.fabricIndex = fabricIndex; + this.rootPublicKey = rootPublicKey; + this.vendorId = vendorId; + this.fabricId = fabricId; + this.nodeId = nodeId; + this.label = label; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OperationalCredentialsClusterFabricDescriptor {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\trootPublicKey: "); + output.append(Arrays.toString(rootPublicKey)); + output.append("\n"); + output.append("\tvendorId: "); + output.append(vendorId); + output.append("\n"); + output.append("\tfabricId: "); + output.append(fabricId); + output.append("\n"); + output.append("\tnodeId: "); + output.append(nodeId); + output.append("\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class OperationalCredentialsClusterNOCStruct { +public Integer fabricIndex; +public byte[] noc; +public @Nullable byte[] icac; + + public OperationalCredentialsClusterNOCStruct( + Integer fabricIndex + , byte[] noc + , @Nullable byte[] icac + ) { + this.fabricIndex = fabricIndex; + this.noc = noc; + this.icac = icac; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OperationalCredentialsClusterNOCStruct {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tnoc: "); + output.append(Arrays.toString(noc)); + output.append("\n"); + output.append("\ticac: "); + output.append(Arrays.toString(icac)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class PowerSourceClusterBatChargeFaultChangeType { +public ArrayList current; +public ArrayList previous; + + public PowerSourceClusterBatChargeFaultChangeType( + ArrayList current + , ArrayList previous + ) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatChargeFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class PowerSourceClusterBatFaultChangeType { +public ArrayList current; +public ArrayList previous; + + public PowerSourceClusterBatFaultChangeType( + ArrayList current + , ArrayList previous + ) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class PowerSourceClusterWiredFaultChangeType { +public ArrayList current; +public ArrayList previous; + + public PowerSourceClusterWiredFaultChangeType( + ArrayList current + , ArrayList previous + ) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterWiredFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ScenesClusterSceneExtensionFieldSet { +public Long clusterId; +public Integer length; +public Integer value; + + public ScenesClusterSceneExtensionFieldSet( + Long clusterId + , Integer length + , Integer value + ) { + this.clusterId = clusterId; + this.length = length; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ScenesClusterSceneExtensionFieldSet {\n"); + output.append("\tclusterId: "); + output.append(clusterId); + output.append("\n"); + output.append("\tlength: "); + output.append(length); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class SoftwareDiagnosticsClusterSoftwareFaultStruct { +public Long id; +public String name; +public byte[] faultRecording; + + public SoftwareDiagnosticsClusterSoftwareFaultStruct( + Long id + , String name + , byte[] faultRecording + ) { + this.id = id; + this.name = name; + this.faultRecording = faultRecording; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SoftwareDiagnosticsClusterSoftwareFaultStruct {\n"); + output.append("\tid: "); + output.append(id); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tfaultRecording: "); + output.append(Arrays.toString(faultRecording)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class SoftwareDiagnosticsClusterThreadMetrics { +public Long id; +public String name; +public Long stackFreeCurrent; +public Long stackFreeMinimum; +public Long stackSize; + + public SoftwareDiagnosticsClusterThreadMetrics( + Long id + , String name + , Long stackFreeCurrent + , Long stackFreeMinimum + , Long stackSize + ) { + this.id = id; + this.name = name; + this.stackFreeCurrent = stackFreeCurrent; + this.stackFreeMinimum = stackFreeMinimum; + this.stackSize = stackSize; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SoftwareDiagnosticsClusterThreadMetrics {\n"); + output.append("\tid: "); + output.append(id); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tstackFreeCurrent: "); + output.append(stackFreeCurrent); + output.append("\n"); + output.append("\tstackFreeMinimum: "); + output.append(stackFreeMinimum); + output.append("\n"); + output.append("\tstackSize: "); + output.append(stackSize); + output.append("\n"); + output.append("}\n"); + return output.toString(); } } + +public static class TargetNavigatorClusterTargetInfo { +public Integer identifier; +public String name; + + public TargetNavigatorClusterTargetInfo( + Integer identifier + , String name + ) { + this.identifier = identifier; + this.name = name; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TargetNavigatorClusterTargetInfo {\n"); + output.append("\tidentifier: "); + output.append(identifier); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterSimpleStruct { +public Integer a; +public Boolean b; +public Integer c; +public byte[] d; +public String e; +public Integer f; +public Float g; +public Double h; + + public TestClusterClusterSimpleStruct( + Integer a + , Boolean b + , Integer c + , byte[] d + , String e + , Integer f + , Float g + , Double h + ) { + this.a = a; + this.b = b; + this.c = c; + this.d = d; + this.e = e; + this.f = f; + this.g = g; + this.h = h; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterSimpleStruct {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("\td: "); + output.append(Arrays.toString(d)); + output.append("\n"); + output.append("\te: "); + output.append(e); + output.append("\n"); + output.append("\tf: "); + output.append(f); + output.append("\n"); + output.append("\tg: "); + output.append(g); + output.append("\n"); + output.append("\th: "); + output.append(h); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterNullablesAndOptionalsStruct { +public @Nullable Integer nullableInt; +public Optional optionalInt; +public @Nullable Optional nullableOptionalInt; +public @Nullable String nullableString; +public Optional optionalString; +public @Nullable Optional nullableOptionalString; +public @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct; +public Optional optionalStruct; +public @Nullable Optional nullableOptionalStruct; +public @Nullable ArrayList nullableList; +public Optional> optionalList; +public @Nullable Optional> nullableOptionalList; + + public TestClusterClusterNullablesAndOptionalsStruct( + @Nullable Integer nullableInt + , Optional optionalInt + , @Nullable Optional nullableOptionalInt + , @Nullable String nullableString + , Optional optionalString + , @Nullable Optional nullableOptionalString + , @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct + , Optional optionalStruct + , @Nullable Optional nullableOptionalStruct + , @Nullable ArrayList nullableList + , Optional> optionalList + , @Nullable Optional> nullableOptionalList + ) { + this.nullableInt = nullableInt; + this.optionalInt = optionalInt; + this.nullableOptionalInt = nullableOptionalInt; + this.nullableString = nullableString; + this.optionalString = optionalString; + this.nullableOptionalString = nullableOptionalString; + this.nullableStruct = nullableStruct; + this.optionalStruct = optionalStruct; + this.nullableOptionalStruct = nullableOptionalStruct; + this.nullableList = nullableList; + this.optionalList = optionalList; + this.nullableOptionalList = nullableOptionalList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNullablesAndOptionalsStruct {\n"); + output.append("\tnullableInt: "); + output.append(nullableInt); + output.append("\n"); + output.append("\toptionalInt: "); + output.append(optionalInt); + output.append("\n"); + output.append("\tnullableOptionalInt: "); + output.append(nullableOptionalInt); + output.append("\n"); + output.append("\tnullableString: "); + output.append(nullableString); + output.append("\n"); + output.append("\toptionalString: "); + output.append(optionalString); + output.append("\n"); + output.append("\tnullableOptionalString: "); + output.append(nullableOptionalString); + output.append("\n"); + output.append("\tnullableStruct: "); + output.append(nullableStruct); + output.append("\n"); + output.append("\toptionalStruct: "); + output.append(optionalStruct); + output.append("\n"); + output.append("\tnullableOptionalStruct: "); + output.append(nullableOptionalStruct); + output.append("\n"); + output.append("\tnullableList: "); + output.append(nullableList); + output.append("\n"); + output.append("\toptionalList: "); + output.append(optionalList); + output.append("\n"); + output.append("\tnullableOptionalList: "); + output.append(nullableOptionalList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterNestedStruct { +public Integer a; +public Boolean b; +public ChipStructs.TestClusterClusterSimpleStruct c; + + public TestClusterClusterNestedStruct( + Integer a + , Boolean b + , ChipStructs.TestClusterClusterSimpleStruct c + ) { + this.a = a; + this.b = b; + this.c = c; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNestedStruct {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterNestedStructList { +public Integer a; +public Boolean b; +public ChipStructs.TestClusterClusterSimpleStruct c; +public ArrayList d; +public ArrayList e; +public ArrayList f; +public ArrayList g; + + public TestClusterClusterNestedStructList( + Integer a + , Boolean b + , ChipStructs.TestClusterClusterSimpleStruct c + , ArrayList d + , ArrayList e + , ArrayList f + , ArrayList g + ) { + this.a = a; + this.b = b; + this.c = c; + this.d = d; + this.e = e; + this.f = f; + this.g = g; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNestedStructList {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("\td: "); + output.append(d); + output.append("\n"); + output.append("\te: "); + output.append(e); + output.append("\n"); + output.append("\tf: "); + output.append(f); + output.append("\n"); + output.append("\tg: "); + output.append(g); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterDoubleNestedStructList { +public ArrayList a; + + public TestClusterClusterDoubleNestedStructList( + ArrayList a + ) { + this.a = a; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterDoubleNestedStructList {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterTestFabricScoped { +public Integer fabricIndex; + + public TestClusterClusterTestFabricScoped( + Integer fabricIndex + ) { + this.fabricIndex = fabricIndex; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterTestFabricScoped {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterTestListStructOctet { +public Long fabricIndex; +public byte[] operationalCert; + + public TestClusterClusterTestListStructOctet( + Long fabricIndex + , byte[] operationalCert + ) { + this.fabricIndex = fabricIndex; + this.operationalCert = operationalCert; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterTestListStructOctet {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\toperationalCert: "); + output.append(Arrays.toString(operationalCert)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ThreadNetworkDiagnosticsClusterNeighborTable { +public Long extAddress; +public Long age; +public Integer rloc16; +public Long linkFrameCounter; +public Long mleFrameCounter; +public Integer lqi; +public Integer averageRssi; +public Integer lastRssi; +public Integer frameErrorRate; +public Integer messageErrorRate; +public Boolean rxOnWhenIdle; +public Boolean fullThreadDevice; +public Boolean fullNetworkData; +public Boolean isChild; + + public ThreadNetworkDiagnosticsClusterNeighborTable( + Long extAddress + , Long age + , Integer rloc16 + , Long linkFrameCounter + , Long mleFrameCounter + , Integer lqi + , Integer averageRssi + , Integer lastRssi + , Integer frameErrorRate + , Integer messageErrorRate + , Boolean rxOnWhenIdle + , Boolean fullThreadDevice + , Boolean fullNetworkData + , Boolean isChild + ) { + this.extAddress = extAddress; + this.age = age; + this.rloc16 = rloc16; + this.linkFrameCounter = linkFrameCounter; + this.mleFrameCounter = mleFrameCounter; + this.lqi = lqi; + this.averageRssi = averageRssi; + this.lastRssi = lastRssi; + this.frameErrorRate = frameErrorRate; + this.messageErrorRate = messageErrorRate; + this.rxOnWhenIdle = rxOnWhenIdle; + this.fullThreadDevice = fullThreadDevice; + this.fullNetworkData = fullNetworkData; + this.isChild = isChild; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterNeighborTable {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\tage: "); + output.append(age); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\tlinkFrameCounter: "); + output.append(linkFrameCounter); + output.append("\n"); + output.append("\tmleFrameCounter: "); + output.append(mleFrameCounter); + output.append("\n"); + output.append("\tlqi: "); + output.append(lqi); + output.append("\n"); + output.append("\taverageRssi: "); + output.append(averageRssi); + output.append("\n"); + output.append("\tlastRssi: "); + output.append(lastRssi); + output.append("\n"); + output.append("\tframeErrorRate: "); + output.append(frameErrorRate); + output.append("\n"); + output.append("\tmessageErrorRate: "); + output.append(messageErrorRate); + output.append("\n"); + output.append("\trxOnWhenIdle: "); + output.append(rxOnWhenIdle); + output.append("\n"); + output.append("\tfullThreadDevice: "); + output.append(fullThreadDevice); + output.append("\n"); + output.append("\tfullNetworkData: "); + output.append(fullNetworkData); + output.append("\n"); + output.append("\tisChild: "); + output.append(isChild); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ThreadNetworkDiagnosticsClusterOperationalDatasetComponents { +public Boolean activeTimestampPresent; +public Boolean pendingTimestampPresent; +public Boolean masterKeyPresent; +public Boolean networkNamePresent; +public Boolean extendedPanIdPresent; +public Boolean meshLocalPrefixPresent; +public Boolean delayPresent; +public Boolean panIdPresent; +public Boolean channelPresent; +public Boolean pskcPresent; +public Boolean securityPolicyPresent; +public Boolean channelMaskPresent; + + public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents( + Boolean activeTimestampPresent + , Boolean pendingTimestampPresent + , Boolean masterKeyPresent + , Boolean networkNamePresent + , Boolean extendedPanIdPresent + , Boolean meshLocalPrefixPresent + , Boolean delayPresent + , Boolean panIdPresent + , Boolean channelPresent + , Boolean pskcPresent + , Boolean securityPolicyPresent + , Boolean channelMaskPresent + ) { + this.activeTimestampPresent = activeTimestampPresent; + this.pendingTimestampPresent = pendingTimestampPresent; + this.masterKeyPresent = masterKeyPresent; + this.networkNamePresent = networkNamePresent; + this.extendedPanIdPresent = extendedPanIdPresent; + this.meshLocalPrefixPresent = meshLocalPrefixPresent; + this.delayPresent = delayPresent; + this.panIdPresent = panIdPresent; + this.channelPresent = channelPresent; + this.pskcPresent = pskcPresent; + this.securityPolicyPresent = securityPolicyPresent; + this.channelMaskPresent = channelMaskPresent; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterOperationalDatasetComponents {\n"); + output.append("\tactiveTimestampPresent: "); + output.append(activeTimestampPresent); + output.append("\n"); + output.append("\tpendingTimestampPresent: "); + output.append(pendingTimestampPresent); + output.append("\n"); + output.append("\tmasterKeyPresent: "); + output.append(masterKeyPresent); + output.append("\n"); + output.append("\tnetworkNamePresent: "); + output.append(networkNamePresent); + output.append("\n"); + output.append("\textendedPanIdPresent: "); + output.append(extendedPanIdPresent); + output.append("\n"); + output.append("\tmeshLocalPrefixPresent: "); + output.append(meshLocalPrefixPresent); + output.append("\n"); + output.append("\tdelayPresent: "); + output.append(delayPresent); + output.append("\n"); + output.append("\tpanIdPresent: "); + output.append(panIdPresent); + output.append("\n"); + output.append("\tchannelPresent: "); + output.append(channelPresent); + output.append("\n"); + output.append("\tpskcPresent: "); + output.append(pskcPresent); + output.append("\n"); + output.append("\tsecurityPolicyPresent: "); + output.append(securityPolicyPresent); + output.append("\n"); + output.append("\tchannelMaskPresent: "); + output.append(channelMaskPresent); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ThreadNetworkDiagnosticsClusterRouteTable { +public Long extAddress; +public Integer rloc16; +public Integer routerId; +public Integer nextHop; +public Integer pathCost; +public Integer LQIIn; +public Integer LQIOut; +public Integer age; +public Boolean allocated; +public Boolean linkEstablished; + + public ThreadNetworkDiagnosticsClusterRouteTable( + Long extAddress + , Integer rloc16 + , Integer routerId + , Integer nextHop + , Integer pathCost + , Integer LQIIn + , Integer LQIOut + , Integer age + , Boolean allocated + , Boolean linkEstablished + ) { + this.extAddress = extAddress; + this.rloc16 = rloc16; + this.routerId = routerId; + this.nextHop = nextHop; + this.pathCost = pathCost; + this.LQIIn = LQIIn; + this.LQIOut = LQIOut; + this.age = age; + this.allocated = allocated; + this.linkEstablished = linkEstablished; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterRouteTable {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\trouterId: "); + output.append(routerId); + output.append("\n"); + output.append("\tnextHop: "); + output.append(nextHop); + output.append("\n"); + output.append("\tpathCost: "); + output.append(pathCost); + output.append("\n"); + output.append("\tLQIIn: "); + output.append(LQIIn); + output.append("\n"); + output.append("\tLQIOut: "); + output.append(LQIOut); + output.append("\n"); + output.append("\tage: "); + output.append(age); + output.append("\n"); + output.append("\tallocated: "); + output.append(allocated); + output.append("\n"); + output.append("\tlinkEstablished: "); + output.append(linkEstablished); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ThreadNetworkDiagnosticsClusterSecurityPolicy { +public Integer rotationTime; +public Integer flags; + + public ThreadNetworkDiagnosticsClusterSecurityPolicy( + Integer rotationTime + , Integer flags + ) { + this.rotationTime = rotationTime; + this.flags = flags; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterSecurityPolicy {\n"); + output.append("\trotationTime: "); + output.append(rotationTime); + output.append("\n"); + output.append("\tflags: "); + output.append(flags); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class UserLabelClusterLabelStruct { +public String label; +public String value; + + public UserLabelClusterLabelStruct( + String label + , String value + ) { + this.label = label; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("UserLabelClusterLabelStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +} \ No newline at end of file diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index 8bead24d836255..206c331e05b755 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -20,24 +20,26 @@ package chip.devicecontroller; import androidx.annotation.Nullable; -import chip.clusterinfo.ClusterCommandCallback; -import chip.clusterinfo.ClusterInfo; -import chip.clusterinfo.CommandParameterInfo; -import chip.clusterinfo.CommandResponseInfo; -import chip.clusterinfo.DelegatedClusterCallback; -import chip.clusterinfo.InteractionInfo; -import chip.devicecontroller.ChipClusters.DefaultClusterCallback; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Optional; +import androidx.annotation.Nullable; +import chip.clusterinfo.ClusterInfo; +import chip.clusterinfo.InteractionInfo; +import chip.clusterinfo.CommandParameterInfo; +import chip.clusterinfo.DelegatedClusterCallback; +import chip.clusterinfo.ClusterCommandCallback; +import chip.clusterinfo.CommandResponseInfo; +import chip.devicecontroller.ChipClusters.DefaultClusterCallback; +import chip.devicecontroller.ClusterReadMapping; +import chip.devicecontroller.ClusterWriteMapping; public class ClusterInfoMapping { - public static class DelegatedCharStringAttributeCallback - implements ChipClusters.CharStringAttributeCallback, DelegatedClusterCallback { + public static class DelegatedCharStringAttributeCallback implements ChipClusters.CharStringAttributeCallback, DelegatedClusterCallback { /** Indicates a successful read for a CHAR_STRING attribute. */ private ClusterCommandCallback callback; @@ -60,8 +62,7 @@ public void onError(Exception error) { } } - public static class DelegatedOctetStringAttributeCallback - implements ChipClusters.OctetStringAttributeCallback, DelegatedClusterCallback { + public static class DelegatedOctetStringAttributeCallback implements ChipClusters.OctetStringAttributeCallback, DelegatedClusterCallback { /** Indicates a successful read for an OCTET_STRING attribute. */ private ClusterCommandCallback callback; @@ -84,8 +85,7 @@ public void onError(Exception error) { } } - public static class DelegatedIntegerAttributeCallback - implements ChipClusters.IntegerAttributeCallback, DelegatedClusterCallback { + public static class DelegatedIntegerAttributeCallback implements ChipClusters.IntegerAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -107,8 +107,7 @@ public void onError(Exception error) { } } - public static class DelegatedLongAttributeCallback - implements ChipClusters.LongAttributeCallback, DelegatedClusterCallback { + public static class DelegatedLongAttributeCallback implements ChipClusters.LongAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -130,8 +129,7 @@ public void onError(Exception error) { } } - public static class DelegatedBooleanAttributeCallback - implements ChipClusters.BooleanAttributeCallback, DelegatedClusterCallback { + public static class DelegatedBooleanAttributeCallback implements ChipClusters.BooleanAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -153,8 +151,7 @@ public void onError(Exception error) { } } - public static class DelegatedFloatAttributeCallback - implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { + public static class DelegatedFloatAttributeCallback implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -176,8 +173,7 @@ public void onError(Exception error) { } } - public static class DelegatedDoubleAttributeCallback - implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { + public static class DelegatedDoubleAttributeCallback implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -199,8 +195,7 @@ public void onError(Exception error) { } } - public static class DelegatedDefaultClusterCallback - implements DefaultClusterCallback, DelegatedClusterCallback { + public static class DelegatedDefaultClusterCallback implements DefaultClusterCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -208,8 +203,7 @@ public void setCallbackDelegate(ClusterCommandCallback callback) { this.callback = callback; } - // Parameters and list-adds here should be generated - refer to the template code that creates - // each callback interface. + // Parameters and list-adds here should be generated - refer to the template code that creates each callback interface. @Override public void onSuccess() { Map responseValues = new LinkedHashMap<>(); @@ -222,8880 +216,7545 @@ public void onError(Exception e) { } } - public static class DelegatedAccessControlClusterAclAttributeCallback - implements ChipClusters.AccessControlCluster.AclAttributeCallback, 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 DelegatedAccessControlClusterExtensionAttributeCallback - implements ChipClusters.AccessControlCluster.ExtensionAttributeCallback, - 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 DelegatedAccessControlClusterAttributeListAttributeCallback - implements ChipClusters.AccessControlCluster.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 DelegatedGetSetupPINResponseCallback - implements ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(String setupPIN) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("setupPIN", "String"); - responseValues.put(setupPINResponseValue, setupPIN); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedAccountLoginClusterAttributeListAttributeCallback - implements ChipClusters.AccountLoginCluster.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 DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback - implements ChipClusters.AdministratorCommissioningCluster.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 DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback - implements ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback, - 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 DelegatedApplicationBasicClusterAttributeListAttributeCallback - implements ChipClusters.ApplicationBasicCluster.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 DelegatedLauncherResponseCallback - implements ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback - implements ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback, - 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 DelegatedApplicationLauncherClusterAttributeListAttributeCallback - implements ChipClusters.ApplicationLauncherCluster.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 DelegatedAudioOutputClusterAudioOutputListAttributeCallback - implements ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback, - 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 DelegatedAudioOutputClusterAttributeListAttributeCallback - implements ChipClusters.AudioOutputCluster.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 DelegatedBarrierControlClusterAttributeListAttributeCallback - implements ChipClusters.BarrierControlCluster.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); - } + public static class DelegatedAccessControlClusterAclAttributeCallback implements ChipClusters.AccessControlCluster.AclAttributeCallback, 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 DelegatedAccessControlClusterExtensionAttributeCallback implements ChipClusters.AccessControlCluster.ExtensionAttributeCallback, 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 DelegatedAccessControlClusterAttributeListAttributeCallback implements ChipClusters.AccessControlCluster.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 DelegatedGetSetupPINResponseCallback implements ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(String setupPIN) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("setupPIN", "String"); + responseValues.put(setupPINResponseValue, setupPIN); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedAccountLoginClusterAttributeListAttributeCallback implements ChipClusters.AccountLoginCluster.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 DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback implements ChipClusters.AdministratorCommissioningCluster.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 DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback implements ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback, 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 DelegatedApplicationBasicClusterAttributeListAttributeCallback implements ChipClusters.ApplicationBasicCluster.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 DelegatedLauncherResponseCallback implements ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback implements ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback, 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 DelegatedApplicationLauncherClusterAttributeListAttributeCallback implements ChipClusters.ApplicationLauncherCluster.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 DelegatedAudioOutputClusterAudioOutputListAttributeCallback implements ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback, 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 DelegatedAudioOutputClusterAttributeListAttributeCallback implements ChipClusters.AudioOutputCluster.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 DelegatedBarrierControlClusterAttributeListAttributeCallback implements ChipClusters.BarrierControlCluster.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 DelegatedBasicClusterAttributeListAttributeCallback implements ChipClusters.BasicCluster.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 DelegatedBinaryInputBasicClusterAttributeListAttributeCallback implements ChipClusters.BinaryInputBasicCluster.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 DelegatedBindingClusterAttributeListAttributeCallback implements ChipClusters.BindingCluster.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 DelegatedBooleanStateClusterAttributeListAttributeCallback implements ChipClusters.BooleanStateCluster.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 DelegatedBridgedActionsClusterActionListAttributeCallback implements ChipClusters.BridgedActionsCluster.ActionListAttributeCallback, 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 DelegatedBridgedActionsClusterEndpointListAttributeCallback implements ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback, 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 DelegatedBridgedActionsClusterAttributeListAttributeCallback implements ChipClusters.BridgedActionsCluster.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 DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback implements ChipClusters.BridgedDeviceBasicCluster.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 DelegatedChangeChannelResponseCallback implements ChipClusters.ChannelCluster.ChangeChannelResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType) { + Map responseValues = new LinkedHashMap<>(); + // channelMatch: Struct ChannelInfo + // Conversion from this type to Java is not properly implemented yet + CommandResponseInfo errorTypeResponseValue = new CommandResponseInfo("errorType", "Integer"); + responseValues.put(errorTypeResponseValue, errorType); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedChannelClusterChannelListAttributeCallback implements ChipClusters.ChannelCluster.ChannelListAttributeCallback, 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 DelegatedChannelClusterAttributeListAttributeCallback implements ChipClusters.ChannelCluster.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 DelegatedColorControlClusterAttributeListAttributeCallback implements ChipClusters.ColorControlCluster.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 DelegatedLaunchResponseCallback implements ChipClusters.ContentLauncherCluster.LaunchResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback implements ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback, 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 DelegatedContentLauncherClusterAttributeListAttributeCallback implements ChipClusters.ContentLauncherCluster.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 DelegatedDescriptorClusterDeviceListAttributeCallback implements ChipClusters.DescriptorCluster.DeviceListAttributeCallback, 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 DelegatedDescriptorClusterServerListAttributeCallback implements ChipClusters.DescriptorCluster.ServerListAttributeCallback, 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 DelegatedDescriptorClusterClientListAttributeCallback implements ChipClusters.DescriptorCluster.ClientListAttributeCallback, 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 DelegatedDescriptorClusterPartsListAttributeCallback implements ChipClusters.DescriptorCluster.PartsListAttributeCallback, 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 DelegatedDescriptorClusterAttributeListAttributeCallback implements ChipClusters.DescriptorCluster.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 DelegatedRetrieveLogsResponseCallback implements ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo contentResponseValue = new CommandResponseInfo("content", "byte[]"); + responseValues.put(contentResponseValue, content); + CommandResponseInfo timeStampResponseValue = new CommandResponseInfo("timeStamp", "Long"); + responseValues.put(timeStampResponseValue, timeStamp); + CommandResponseInfo timeSinceBootResponseValue = new CommandResponseInfo("timeSinceBoot", "Long"); + responseValues.put(timeSinceBootResponseValue, timeSinceBoot); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedDiagnosticLogsClusterAttributeListAttributeCallback implements ChipClusters.DiagnosticLogsCluster.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 DelegatedGetCredentialStatusResponseCallback implements ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo credentialExistsResponseValue = new CommandResponseInfo("credentialExists", "Boolean"); + responseValues.put(credentialExistsResponseValue, credentialExists); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo nextCredentialIndexResponseValue = new CommandResponseInfo("nextCredentialIndex", "Integer"); + responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetUserResponseCallback implements ChipClusters.DoorLockCluster.GetUserResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo userNameResponseValue = new CommandResponseInfo("userName", "String"); + responseValues.put(userNameResponseValue, userName); + CommandResponseInfo userUniqueIdResponseValue = new CommandResponseInfo("userUniqueId", "Long"); + responseValues.put(userUniqueIdResponseValue, userUniqueId); + CommandResponseInfo userStatusResponseValue = new CommandResponseInfo("userStatus", "Integer"); + responseValues.put(userStatusResponseValue, userStatus); + CommandResponseInfo userTypeResponseValue = new CommandResponseInfo("userType", "Integer"); + responseValues.put(userTypeResponseValue, userType); + CommandResponseInfo credentialRuleResponseValue = new CommandResponseInfo("credentialRule", "Integer"); + responseValues.put(credentialRuleResponseValue, credentialRule); + // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + CommandResponseInfo creatorFabricIndexResponseValue = new CommandResponseInfo("creatorFabricIndex", "Integer"); + responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); + CommandResponseInfo lastModifiedFabricIndexResponseValue = new CommandResponseInfo("lastModifiedFabricIndex", "Integer"); + responseValues.put(lastModifiedFabricIndexResponseValue, lastModifiedFabricIndex); + CommandResponseInfo nextUserIndexResponseValue = new CommandResponseInfo("nextUserIndex", "Integer"); + responseValues.put(nextUserIndexResponseValue, nextUserIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetWeekDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo weekDayIndexResponseValue = new CommandResponseInfo("weekDayIndex", "Integer"); + responseValues.put(weekDayIndexResponseValue, weekDayIndex); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo daysMaskResponseValue = new CommandResponseInfo("daysMask", "Optional"); + responseValues.put(daysMaskResponseValue, daysMask); + CommandResponseInfo startHourResponseValue = new CommandResponseInfo("startHour", "Optional"); + responseValues.put(startHourResponseValue, startHour); + CommandResponseInfo startMinuteResponseValue = new CommandResponseInfo("startMinute", "Optional"); + responseValues.put(startMinuteResponseValue, startMinute); + CommandResponseInfo endHourResponseValue = new CommandResponseInfo("endHour", "Optional"); + responseValues.put(endHourResponseValue, endHour); + CommandResponseInfo endMinuteResponseValue = new CommandResponseInfo("endMinute", "Optional"); + responseValues.put(endMinuteResponseValue, endMinute); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetYearDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo yearDayIndexResponseValue = new CommandResponseInfo("yearDayIndex", "Integer"); + responseValues.put(yearDayIndexResponseValue, yearDayIndex); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo localStartTimeResponseValue = new CommandResponseInfo("localStartTime", "Optional"); + responseValues.put(localStartTimeResponseValue, localStartTime); + CommandResponseInfo localEndTimeResponseValue = new CommandResponseInfo("localEndTime", "Optional"); + responseValues.put(localEndTimeResponseValue, localEndTime); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSetCredentialResponseCallback implements ChipClusters.DoorLockCluster.SetCredentialResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo nextCredentialIndexResponseValue = new CommandResponseInfo("nextCredentialIndex", "Integer"); + responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedDoorLockClusterAttributeListAttributeCallback implements ChipClusters.DoorLockCluster.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 DelegatedElectricalMeasurementClusterAttributeListAttributeCallback implements ChipClusters.ElectricalMeasurementCluster.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 DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.EthernetNetworkDiagnosticsCluster.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 DelegatedFixedLabelClusterLabelListAttributeCallback implements ChipClusters.FixedLabelCluster.LabelListAttributeCallback, 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 DelegatedFixedLabelClusterAttributeListAttributeCallback implements ChipClusters.FixedLabelCluster.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 DelegatedFlowMeasurementClusterAttributeListAttributeCallback implements ChipClusters.FlowMeasurementCluster.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 DelegatedArmFailSafeResponseCallback implements ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedCommissioningCompleteResponseCallback implements ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSetRegulatoryConfigResponseCallback implements ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback implements ChipClusters.GeneralCommissioningCluster.BasicCommissioningInfoListAttributeCallback, 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 DelegatedGeneralCommissioningClusterAttributeListAttributeCallback implements ChipClusters.GeneralCommissioningCluster.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 DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.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 DelegatedKeySetReadAllIndicesResponseCallback implements ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ArrayList groupKeySetIDs) { + Map responseValues = new LinkedHashMap<>(); + // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedKeySetReadResponseCallback implements ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { + Map responseValues = new LinkedHashMap<>(); + // groupKeySet: Struct GroupKeySet + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback implements ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback, 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 DelegatedGroupKeyManagementClusterGroupTableAttributeCallback implements ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback, 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 DelegatedGroupKeyManagementClusterAttributeListAttributeCallback implements ChipClusters.GroupKeyManagementCluster.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 DelegatedAddGroupResponseCallback implements ChipClusters.GroupsCluster.AddGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetGroupMembershipResponseCallback implements ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer capacity, ArrayList groupList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); + responseValues.put(capacityResponseValue, capacity); + // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveGroupResponseCallback implements ChipClusters.GroupsCluster.RemoveGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedViewGroupResponseCallback implements ChipClusters.GroupsCluster.ViewGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, String groupName) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo groupNameResponseValue = new CommandResponseInfo("groupName", "String"); + responseValues.put(groupNameResponseValue, groupName); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedGroupsClusterAttributeListAttributeCallback implements ChipClusters.GroupsCluster.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 DelegatedIdentifyQueryResponseCallback implements ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer timeout) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo timeoutResponseValue = new CommandResponseInfo("timeout", "Integer"); + responseValues.put(timeoutResponseValue, timeout); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedIdentifyClusterAttributeListAttributeCallback implements ChipClusters.IdentifyCluster.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 DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback implements ChipClusters.IlluminanceMeasurementCluster.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 DelegatedSendKeyResponseCallback implements ChipClusters.KeypadInputCluster.SendKeyResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedKeypadInputClusterAttributeListAttributeCallback implements ChipClusters.KeypadInputCluster.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 DelegatedLevelControlClusterAttributeListAttributeCallback implements ChipClusters.LevelControlCluster.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 DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback implements ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback, 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 DelegatedLowPowerClusterAttributeListAttributeCallback implements ChipClusters.LowPowerCluster.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 DelegatedMediaInputClusterMediaInputListAttributeCallback implements ChipClusters.MediaInputCluster.MediaInputListAttributeCallback, 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 DelegatedMediaInputClusterAttributeListAttributeCallback implements ChipClusters.MediaInputCluster.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 DelegatedPlaybackResponseCallback implements ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedMediaPlaybackClusterAttributeListAttributeCallback implements ChipClusters.MediaPlaybackCluster.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 DelegatedModeSelectClusterSupportedModesAttributeCallback implements ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback, 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 DelegatedModeSelectClusterAttributeListAttributeCallback implements ChipClusters.ModeSelectCluster.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 DelegatedConnectNetworkResponseCallback implements ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText, Long ErrorValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + CommandResponseInfo ErrorValueResponseValue = new CommandResponseInfo("ErrorValue", "Long"); + responseValues.put(ErrorValueResponseValue, ErrorValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNetworkConfigResponseCallback implements ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedScanNetworksResponseCallback implements ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText, Optional> WiFiScanResults, Optional> ThreadScanResults) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + // WiFiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + // ThreadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedNetworkCommissioningClusterNetworksAttributeCallback implements ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback, 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 DelegatedApplyUpdateResponseCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer action, Long delayedActionTime) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo actionResponseValue = new CommandResponseInfo("action", "Integer"); + responseValues.put(actionResponseValue, action); + CommandResponseInfo delayedActionTimeResponseValue = new CommandResponseInfo("delayedActionTime", "Long"); + responseValues.put(delayedActionTimeResponseValue, delayedActionTime); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedQueryImageResponseCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo delayedActionTimeResponseValue = new CommandResponseInfo("delayedActionTime", "Optional"); + responseValues.put(delayedActionTimeResponseValue, delayedActionTime); + CommandResponseInfo imageURIResponseValue = new CommandResponseInfo("imageURI", "Optional"); + responseValues.put(imageURIResponseValue, imageURI); + CommandResponseInfo softwareVersionResponseValue = new CommandResponseInfo("softwareVersion", "Optional"); + responseValues.put(softwareVersionResponseValue, softwareVersion); + CommandResponseInfo softwareVersionStringResponseValue = new CommandResponseInfo("softwareVersionString", "Optional"); + responseValues.put(softwareVersionStringResponseValue, softwareVersionString); + CommandResponseInfo updateTokenResponseValue = new CommandResponseInfo("updateToken", "Optional"); + responseValues.put(updateTokenResponseValue, updateToken); + CommandResponseInfo userConsentNeededResponseValue = new CommandResponseInfo("userConsentNeeded", "Optional"); + responseValues.put(userConsentNeededResponseValue, userConsentNeeded); + CommandResponseInfo metadataForRequestorResponseValue = new CommandResponseInfo("metadataForRequestor", "Optional"); + responseValues.put(metadataForRequestorResponseValue, metadataForRequestor); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.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 DelegatedOtaSoftwareUpdateRequestorClusterDefaultOtaProvidersAttributeCallback implements ChipClusters.OtaSoftwareUpdateRequestorCluster.DefaultOtaProvidersAttributeCallback, 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 DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback implements ChipClusters.OtaSoftwareUpdateRequestorCluster.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 DelegatedOccupancySensingClusterAttributeListAttributeCallback implements ChipClusters.OccupancySensingCluster.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 DelegatedOnOffClusterAttributeListAttributeCallback implements ChipClusters.OnOffCluster.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 DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback implements ChipClusters.OnOffSwitchConfigurationCluster.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 DelegatedAttestationResponseCallback implements ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] AttestationElements, byte[] Signature) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo AttestationElementsResponseValue = new CommandResponseInfo("AttestationElements", "byte[]"); + responseValues.put(AttestationElementsResponseValue, AttestationElements); + CommandResponseInfo SignatureResponseValue = new CommandResponseInfo("Signature", "byte[]"); + responseValues.put(SignatureResponseValue, Signature); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedCertificateChainResponseCallback implements ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] Certificate) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo CertificateResponseValue = new CommandResponseInfo("Certificate", "byte[]"); + responseValues.put(CertificateResponseValue, Certificate); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNOCResponseCallback implements ChipClusters.OperationalCredentialsCluster.NOCResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer StatusCode, Integer FabricIndex, String DebugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo StatusCodeResponseValue = new CommandResponseInfo("StatusCode", "Integer"); + responseValues.put(StatusCodeResponseValue, StatusCode); + CommandResponseInfo FabricIndexResponseValue = new CommandResponseInfo("FabricIndex", "Integer"); + responseValues.put(FabricIndexResponseValue, FabricIndex); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedOpCSRResponseCallback implements ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] NOCSRElements, byte[] AttestationSignature) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NOCSRElementsResponseValue = new CommandResponseInfo("NOCSRElements", "byte[]"); + responseValues.put(NOCSRElementsResponseValue, NOCSRElements); + CommandResponseInfo AttestationSignatureResponseValue = new CommandResponseInfo("AttestationSignature", "byte[]"); + responseValues.put(AttestationSignatureResponseValue, AttestationSignature); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedOperationalCredentialsClusterNOCsAttributeCallback implements ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback, 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 DelegatedOperationalCredentialsClusterFabricsListAttributeCallback implements ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback, 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 DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback implements ChipClusters.OperationalCredentialsCluster.TrustedRootCertificatesAttributeCallback, 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 DelegatedOperationalCredentialsClusterAttributeListAttributeCallback implements ChipClusters.OperationalCredentialsCluster.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 DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback implements ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback, 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 DelegatedPowerSourceClusterAttributeListAttributeCallback implements ChipClusters.PowerSourceCluster.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 DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback implements ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback, 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 DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback implements ChipClusters.PowerSourceConfigurationCluster.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 DelegatedPressureMeasurementClusterAttributeListAttributeCallback implements ChipClusters.PressureMeasurementCluster.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 DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback implements ChipClusters.PumpConfigurationAndControlCluster.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 DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback implements ChipClusters.RelativeHumidityMeasurementCluster.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 DelegatedAddSceneResponseCallback implements ChipClusters.ScenesCluster.AddSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetSceneMembershipResponseCallback implements ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); + responseValues.put(capacityResponseValue, capacity); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneCountResponseValue = new CommandResponseInfo("sceneCount", "Integer"); + responseValues.put(sceneCountResponseValue, sceneCount); + // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveAllScenesResponseCallback implements ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveSceneResponseCallback implements ChipClusters.ScenesCluster.RemoveSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedStoreSceneResponseCallback implements ChipClusters.ScenesCluster.StoreSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedViewSceneResponseCallback implements ChipClusters.ScenesCluster.ViewSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + CommandResponseInfo transitionTimeResponseValue = new CommandResponseInfo("transitionTime", "Integer"); + responseValues.put(transitionTimeResponseValue, transitionTime); + CommandResponseInfo sceneNameResponseValue = new CommandResponseInfo("sceneName", "String"); + responseValues.put(sceneNameResponseValue, sceneName); + // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedScenesClusterAttributeListAttributeCallback implements ChipClusters.ScenesCluster.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 DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback implements ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback, 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 DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.SoftwareDiagnosticsCluster.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 DelegatedSwitchClusterAttributeListAttributeCallback implements ChipClusters.SwitchCluster.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 DelegatedNavigateTargetResponseCallback implements ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback implements ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback, 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 DelegatedTargetNavigatorClusterAttributeListAttributeCallback implements ChipClusters.TargetNavigatorCluster.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 DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback implements ChipClusters.TemperatureMeasurementCluster.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 DelegatedBooleanResponseCallback implements ChipClusters.TestClusterCluster.BooleanResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Boolean value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Boolean"); + responseValues.put(valueResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSimpleStructResponseCallback implements ChipClusters.TestClusterCluster.SimpleStructResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1) { + Map responseValues = new LinkedHashMap<>(); + // arg1: Struct SimpleStruct + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestAddArgumentsResponseCallback implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer returnValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo returnValueResponseValue = new CommandResponseInfo("returnValue", "Integer"); + responseValues.put(returnValueResponseValue, returnValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestEmitTestEventResponseCallback implements ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Long value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Long"); + responseValues.put(valueResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestEnumsResponseCallback implements ChipClusters.TestClusterCluster.TestEnumsResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer arg1, Integer arg2) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo arg1ResponseValue = new CommandResponseInfo("arg1", "Integer"); + responseValues.put(arg1ResponseValue, arg1); + CommandResponseInfo arg2ResponseValue = new CommandResponseInfo("arg2", "Integer"); + responseValues.put(arg2ResponseValue, arg2); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestListInt8UReverseResponseCallback implements ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ArrayList arg1) { + Map responseValues = new LinkedHashMap<>(); + // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestNullableOptionalResponseCallback implements ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo wasPresentResponseValue = new CommandResponseInfo("wasPresent", "Boolean"); + responseValues.put(wasPresentResponseValue, wasPresent); + CommandResponseInfo wasNullResponseValue = new CommandResponseInfo("wasNull", "Optional"); + responseValues.put(wasNullResponseValue, wasNull); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Optional"); + responseValues.put(valueResponseValue, value); + CommandResponseInfo originalValueResponseValue = new CommandResponseInfo("originalValue", "Optional"); + responseValues.put(originalValueResponseValue, originalValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestSpecificResponseCallback implements ChipClusters.TestClusterCluster.TestSpecificResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer returnValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo returnValueResponseValue = new CommandResponseInfo("returnValue", "Integer"); + responseValues.put(returnValueResponseValue, returnValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedTestClusterClusterListInt8uAttributeCallback implements ChipClusters.TestClusterCluster.ListInt8uAttributeCallback, 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 DelegatedTestClusterClusterListOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback, 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 DelegatedTestClusterClusterListStructOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback, 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 DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback implements ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback, 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 DelegatedTestClusterClusterListLongOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback, 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 DelegatedTestClusterClusterAttributeListAttributeCallback implements ChipClusters.TestClusterCluster.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 DelegatedGetRelayStatusLogResponseCallback implements ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo timeOfDayResponseValue = new CommandResponseInfo("timeOfDay", "Integer"); + responseValues.put(timeOfDayResponseValue, timeOfDay); + CommandResponseInfo relayStatusResponseValue = new CommandResponseInfo("relayStatus", "Integer"); + responseValues.put(relayStatusResponseValue, relayStatus); + CommandResponseInfo localTemperatureResponseValue = new CommandResponseInfo("localTemperature", "Integer"); + responseValues.put(localTemperatureResponseValue, localTemperature); + CommandResponseInfo humidityInPercentageResponseValue = new CommandResponseInfo("humidityInPercentage", "Integer"); + responseValues.put(humidityInPercentageResponseValue, humidityInPercentage); + CommandResponseInfo setpointResponseValue = new CommandResponseInfo("setpoint", "Integer"); + responseValues.put(setpointResponseValue, setpoint); + CommandResponseInfo unreadEntriesResponseValue = new CommandResponseInfo("unreadEntries", "Integer"); + responseValues.put(unreadEntriesResponseValue, unreadEntries); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetWeeklyScheduleResponseCallback implements ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo numberOfTransitionsForSequenceResponseValue = new CommandResponseInfo("numberOfTransitionsForSequence", "Integer"); + responseValues.put(numberOfTransitionsForSequenceResponseValue, numberOfTransitionsForSequence); + CommandResponseInfo dayOfWeekForSequenceResponseValue = new CommandResponseInfo("dayOfWeekForSequence", "Integer"); + responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); + CommandResponseInfo modeForSequenceResponseValue = new CommandResponseInfo("modeForSequence", "Integer"); + responseValues.put(modeForSequenceResponseValue, modeForSequence); + // payload: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedThermostatClusterAttributeListAttributeCallback implements ChipClusters.ThermostatCluster.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 DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback implements ChipClusters.ThermostatUserInterfaceConfigurationCluster.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 DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.OperationalDatasetComponentsAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.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 DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback implements ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback, 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 DelegatedUserLabelClusterLabelListAttributeCallback implements ChipClusters.UserLabelCluster.LabelListAttributeCallback, 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 DelegatedWakeOnLanClusterAttributeListAttributeCallback implements ChipClusters.WakeOnLanCluster.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 DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.WiFiNetworkDiagnosticsCluster.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 DelegatedWindowCoveringClusterAttributeListAttributeCallback implements ChipClusters.WindowCoveringCluster.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 Map getClusterMap() { + Map clusterMap = initializeClusterMap(); + Map> commandMap = getCommandMap(); + combineCommand(clusterMap, commandMap); + Map> readAttributeMap = new ClusterReadMapping().getReadAttributeMap(); + combineCommand(clusterMap, readAttributeMap); + Map> writeAttributeMap = new ClusterWriteMapping().getWriteAttributeMap(); + combineCommand(clusterMap, writeAttributeMap); + return clusterMap; + } - @Override - public void onError(Exception ex) { - callback.onFailure(ex); - } + public Map initializeClusterMap() { + Map clusterMap = new HashMap<>(); + ClusterInfo accessControlClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AccessControlCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("accessControl", accessControlClusterInfo); + ClusterInfo accountLoginClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("accountLogin", accountLoginClusterInfo); + ClusterInfo administratorCommissioningClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); + ClusterInfo applicationBasicClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("applicationBasic", applicationBasicClusterInfo); + ClusterInfo applicationLauncherClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); + ClusterInfo audioOutputClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("audioOutput", audioOutputClusterInfo); + ClusterInfo barrierControlClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("barrierControl", barrierControlClusterInfo); + ClusterInfo basicClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("basic", basicClusterInfo); + ClusterInfo binaryInputBasicClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); + ClusterInfo bindingClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("binding", bindingClusterInfo); + ClusterInfo booleanStateClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("booleanState", booleanStateClusterInfo); + ClusterInfo bridgedActionsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("bridgedActions", bridgedActionsClusterInfo); + ClusterInfo bridgedDeviceBasicClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); + ClusterInfo channelClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ChannelCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("channel", channelClusterInfo); + ClusterInfo colorControlClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("colorControl", colorControlClusterInfo); + ClusterInfo contentLauncherClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("contentLauncher", contentLauncherClusterInfo); + ClusterInfo descriptorClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("descriptor", descriptorClusterInfo); + ClusterInfo diagnosticLogsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); + ClusterInfo doorLockClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("doorLock", doorLockClusterInfo); + ClusterInfo electricalMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); + ClusterInfo ethernetNetworkDiagnosticsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); + ClusterInfo fixedLabelClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("fixedLabel", fixedLabelClusterInfo); + ClusterInfo flowMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); + ClusterInfo generalCommissioningClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); + ClusterInfo generalDiagnosticsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); + ClusterInfo groupKeyManagementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); + ClusterInfo groupsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("groups", groupsClusterInfo); + ClusterInfo identifyClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("identify", identifyClusterInfo); + ClusterInfo illuminanceMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); + ClusterInfo keypadInputClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("keypadInput", keypadInputClusterInfo); + ClusterInfo levelControlClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("levelControl", levelControlClusterInfo); + ClusterInfo localizationConfigurationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LocalizationConfigurationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("localizationConfiguration", localizationConfigurationClusterInfo); + ClusterInfo lowPowerClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("lowPower", lowPowerClusterInfo); + ClusterInfo mediaInputClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("mediaInput", mediaInputClusterInfo); + ClusterInfo mediaPlaybackClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); + ClusterInfo modeSelectClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("modeSelect", modeSelectClusterInfo); + ClusterInfo networkCommissioningClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); + ClusterInfo otaSoftwareUpdateProviderClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); + ClusterInfo otaSoftwareUpdateRequestorClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); + ClusterInfo occupancySensingClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("occupancySensing", occupancySensingClusterInfo); + ClusterInfo onOffClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("onOff", onOffClusterInfo); + ClusterInfo onOffSwitchConfigurationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); + ClusterInfo operationalCredentialsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); + ClusterInfo powerSourceClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("powerSource", powerSourceClusterInfo); + ClusterInfo powerSourceConfigurationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PowerSourceConfigurationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInfo); + ClusterInfo pressureMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); + ClusterInfo pumpConfigurationAndControlClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); + ClusterInfo relativeHumidityMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); + ClusterInfo scenesClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("scenes", scenesClusterInfo); + ClusterInfo softwareDiagnosticsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); + ClusterInfo switchClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("switch", switchClusterInfo); + ClusterInfo targetNavigatorClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("targetNavigator", targetNavigatorClusterInfo); + ClusterInfo temperatureMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); + ClusterInfo testClusterClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("testCluster", testClusterClusterInfo); + ClusterInfo thermostatClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("thermostat", thermostatClusterInfo); + ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); + ClusterInfo threadNetworkDiagnosticsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); + ClusterInfo timeFormatLocalizationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TimeFormatLocalizationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("timeFormatLocalization", timeFormatLocalizationClusterInfo); + ClusterInfo unitLocalizationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.UnitLocalizationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("unitLocalization", unitLocalizationClusterInfo); + ClusterInfo userLabelClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.UserLabelCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("userLabel", userLabelClusterInfo); + ClusterInfo wakeOnLanClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); + ClusterInfo wiFiNetworkDiagnosticsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); + ClusterInfo windowCoveringClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("windowCovering", windowCoveringClusterInfo); + return clusterMap; + } + + public void combineCommand(Map destination, Map> source) { + destination.get("accessControl").combineCommands(source.get("accessControl")); + destination.get("accountLogin").combineCommands(source.get("accountLogin")); + destination.get("administratorCommissioning").combineCommands(source.get("administratorCommissioning")); + destination.get("applicationBasic").combineCommands(source.get("applicationBasic")); + destination.get("applicationLauncher").combineCommands(source.get("applicationLauncher")); + destination.get("audioOutput").combineCommands(source.get("audioOutput")); + destination.get("barrierControl").combineCommands(source.get("barrierControl")); + destination.get("basic").combineCommands(source.get("basic")); + destination.get("binaryInputBasic").combineCommands(source.get("binaryInputBasic")); + destination.get("binding").combineCommands(source.get("binding")); + destination.get("booleanState").combineCommands(source.get("booleanState")); + destination.get("bridgedActions").combineCommands(source.get("bridgedActions")); + destination.get("bridgedDeviceBasic").combineCommands(source.get("bridgedDeviceBasic")); + destination.get("channel").combineCommands(source.get("channel")); + destination.get("colorControl").combineCommands(source.get("colorControl")); + destination.get("contentLauncher").combineCommands(source.get("contentLauncher")); + destination.get("descriptor").combineCommands(source.get("descriptor")); + destination.get("diagnosticLogs").combineCommands(source.get("diagnosticLogs")); + destination.get("doorLock").combineCommands(source.get("doorLock")); + destination.get("electricalMeasurement").combineCommands(source.get("electricalMeasurement")); + destination.get("ethernetNetworkDiagnostics").combineCommands(source.get("ethernetNetworkDiagnostics")); + destination.get("fixedLabel").combineCommands(source.get("fixedLabel")); + destination.get("flowMeasurement").combineCommands(source.get("flowMeasurement")); + destination.get("generalCommissioning").combineCommands(source.get("generalCommissioning")); + destination.get("generalDiagnostics").combineCommands(source.get("generalDiagnostics")); + destination.get("groupKeyManagement").combineCommands(source.get("groupKeyManagement")); + destination.get("groups").combineCommands(source.get("groups")); + destination.get("identify").combineCommands(source.get("identify")); + destination.get("illuminanceMeasurement").combineCommands(source.get("illuminanceMeasurement")); + destination.get("keypadInput").combineCommands(source.get("keypadInput")); + destination.get("levelControl").combineCommands(source.get("levelControl")); + destination.get("localizationConfiguration").combineCommands(source.get("localizationConfiguration")); + destination.get("lowPower").combineCommands(source.get("lowPower")); + destination.get("mediaInput").combineCommands(source.get("mediaInput")); + destination.get("mediaPlayback").combineCommands(source.get("mediaPlayback")); + destination.get("modeSelect").combineCommands(source.get("modeSelect")); + destination.get("networkCommissioning").combineCommands(source.get("networkCommissioning")); + destination.get("otaSoftwareUpdateProvider").combineCommands(source.get("otaSoftwareUpdateProvider")); + destination.get("otaSoftwareUpdateRequestor").combineCommands(source.get("otaSoftwareUpdateRequestor")); + destination.get("occupancySensing").combineCommands(source.get("occupancySensing")); + destination.get("onOff").combineCommands(source.get("onOff")); + destination.get("onOffSwitchConfiguration").combineCommands(source.get("onOffSwitchConfiguration")); + destination.get("operationalCredentials").combineCommands(source.get("operationalCredentials")); + destination.get("powerSource").combineCommands(source.get("powerSource")); + destination.get("powerSourceConfiguration").combineCommands(source.get("powerSourceConfiguration")); + destination.get("pressureMeasurement").combineCommands(source.get("pressureMeasurement")); + destination.get("pumpConfigurationAndControl").combineCommands(source.get("pumpConfigurationAndControl")); + destination.get("relativeHumidityMeasurement").combineCommands(source.get("relativeHumidityMeasurement")); + destination.get("scenes").combineCommands(source.get("scenes")); + destination.get("softwareDiagnostics").combineCommands(source.get("softwareDiagnostics")); + destination.get("switch").combineCommands(source.get("switch")); + destination.get("targetNavigator").combineCommands(source.get("targetNavigator")); + destination.get("temperatureMeasurement").combineCommands(source.get("temperatureMeasurement")); + destination.get("testCluster").combineCommands(source.get("testCluster")); + destination.get("thermostat").combineCommands(source.get("thermostat")); + destination.get("thermostatUserInterfaceConfiguration").combineCommands(source.get("thermostatUserInterfaceConfiguration")); + destination.get("threadNetworkDiagnostics").combineCommands(source.get("threadNetworkDiagnostics")); + destination.get("timeFormatLocalization").combineCommands(source.get("timeFormatLocalization")); + destination.get("unitLocalization").combineCommands(source.get("unitLocalization")); + destination.get("userLabel").combineCommands(source.get("userLabel")); + destination.get("wakeOnLan").combineCommands(source.get("wakeOnLan")); + destination.get("wiFiNetworkDiagnostics").combineCommands(source.get("wiFiNetworkDiagnostics")); + destination.get("windowCovering").combineCommands(source.get("windowCovering")); + } + + @SuppressWarnings("unchecked") + public Map> getCommandMap() { + Map> commandMap = new HashMap<>(); + Map accessControlClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("accessControl", accessControlClusterInteractionInfoMap); + Map accountLoginClusterInteractionInfoMap = new LinkedHashMap<>(); + Map accountLogingetSetupPINRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); + accountLogingetSetupPINRequestCommandParams.put("tempAccountIdentifier",accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); + + InteractionInfo accountLogingetSetupPINRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .getSetupPINRequest((ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback) callback + , (String) + commandArguments.get("tempAccountIdentifier") + , 10000 + ); + }, + () -> new DelegatedGetSetupPINResponseCallback(), + accountLogingetSetupPINRequestCommandParams + ); + accountLoginClusterInteractionInfoMap.put("getSetupPINRequest", accountLogingetSetupPINRequestInteractionInfo); + Map accountLoginloginRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); + accountLoginloginRequestCommandParams.put("tempAccountIdentifier",accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); + + CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = new CommandParameterInfo("setupPIN", String.class); + accountLoginloginRequestCommandParams.put("setupPIN",accountLoginloginRequestsetupPINCommandParameterInfo); + + InteractionInfo accountLoginloginRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .loginRequest((DefaultClusterCallback) callback + , (String) + commandArguments.get("tempAccountIdentifier") + , (String) + commandArguments.get("setupPIN") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + accountLoginloginRequestCommandParams + ); + accountLoginClusterInteractionInfoMap.put("loginRequest", accountLoginloginRequestInteractionInfo); + Map accountLoginlogoutRequestCommandParams = new LinkedHashMap(); + InteractionInfo accountLoginlogoutRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .logoutRequest((DefaultClusterCallback) callback + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + accountLoginlogoutRequestCommandParams + ); + accountLoginClusterInteractionInfoMap.put("logoutRequest", accountLoginlogoutRequestInteractionInfo); + commandMap.put("accountLogin", accountLoginClusterInteractionInfoMap); + Map administratorCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); + Map administratorCommissioningopenBasicCommissioningWindowCommandParams = new LinkedHashMap(); + CommandParameterInfo administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); + administratorCommissioningopenBasicCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); + + InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .openBasicCommissioningWindow((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("commissioningTimeout") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningopenBasicCommissioningWindowCommandParams + ); + administratorCommissioningClusterInteractionInfoMap.put("openBasicCommissioningWindow", administratorCommissioningopenBasicCommissioningWindowInteractionInfo); + Map administratorCommissioningopenCommissioningWindowCommandParams = new LinkedHashMap(); + CommandParameterInfo administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = new CommandParameterInfo("PAKEVerifier", byte[].class); + administratorCommissioningopenCommissioningWindowCommandParams.put("PAKEVerifier",administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = new CommandParameterInfo("discriminator", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put("discriminator",administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = new CommandParameterInfo("iterations", Long.class); + administratorCommissioningopenCommissioningWindowCommandParams.put("iterations",administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = new CommandParameterInfo("salt", byte[].class); + administratorCommissioningopenCommissioningWindowCommandParams.put("salt",administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = new CommandParameterInfo("passcodeID", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put("passcodeID",administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); + + InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .openCommissioningWindow((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("commissioningTimeout") + , (byte[]) + commandArguments.get("PAKEVerifier") + , (Integer) + commandArguments.get("discriminator") + , (Long) + commandArguments.get("iterations") + , (byte[]) + commandArguments.get("salt") + , (Integer) + commandArguments.get("passcodeID") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningopenCommissioningWindowCommandParams + ); + administratorCommissioningClusterInteractionInfoMap.put("openCommissioningWindow", administratorCommissioningopenCommissioningWindowInteractionInfo); + Map administratorCommissioningrevokeCommissioningCommandParams = new LinkedHashMap(); + InteractionInfo administratorCommissioningrevokeCommissioningInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .revokeCommissioning((DefaultClusterCallback) callback + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningrevokeCommissioningCommandParams + ); + administratorCommissioningClusterInteractionInfoMap.put("revokeCommissioning", administratorCommissioningrevokeCommissioningInteractionInfo); + commandMap.put("administratorCommissioning", administratorCommissioningClusterInteractionInfoMap); + Map applicationBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("applicationBasic", applicationBasicClusterInteractionInfoMap); + Map applicationLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); + Map applicationLauncherhideAppRequestCommandParams = new LinkedHashMap(); + InteractionInfo applicationLauncherhideAppRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .hideAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback + , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application") + + ); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherhideAppRequestCommandParams + ); + applicationLauncherClusterInteractionInfoMap.put("hideAppRequest", applicationLauncherhideAppRequestInteractionInfo); + Map applicationLauncherlaunchAppRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); + applicationLauncherlaunchAppRequestCommandParams.put("data",applicationLauncherlaunchAppRequestdataCommandParameterInfo); + + InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .launchAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback + , (String) + commandArguments.get("data") + , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application") + + ); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherlaunchAppRequestCommandParams + ); + applicationLauncherClusterInteractionInfoMap.put("launchAppRequest", applicationLauncherlaunchAppRequestInteractionInfo); + Map applicationLauncherstopAppRequestCommandParams = new LinkedHashMap(); + InteractionInfo applicationLauncherstopAppRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .stopAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback + , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application") + + ); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherstopAppRequestCommandParams + ); + applicationLauncherClusterInteractionInfoMap.put("stopAppRequest", applicationLauncherstopAppRequestInteractionInfo); + commandMap.put("applicationLauncher", applicationLauncherClusterInteractionInfoMap); + Map audioOutputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map audioOutputrenameOutputRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); + audioOutputrenameOutputRequestCommandParams.put("index",audioOutputrenameOutputRequestindexCommandParameterInfo); + + CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); + audioOutputrenameOutputRequestCommandParams.put("name",audioOutputrenameOutputRequestnameCommandParameterInfo); + + InteractionInfo audioOutputrenameOutputRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .renameOutputRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("index") + , (String) + commandArguments.get("name") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + audioOutputrenameOutputRequestCommandParams + ); + audioOutputClusterInteractionInfoMap.put("renameOutputRequest", audioOutputrenameOutputRequestInteractionInfo); + Map audioOutputselectOutputRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); + audioOutputselectOutputRequestCommandParams.put("index",audioOutputselectOutputRequestindexCommandParameterInfo); + + InteractionInfo audioOutputselectOutputRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .selectOutputRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("index") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + audioOutputselectOutputRequestCommandParams + ); + audioOutputClusterInteractionInfoMap.put("selectOutputRequest", audioOutputselectOutputRequestInteractionInfo); + commandMap.put("audioOutput", audioOutputClusterInteractionInfoMap); + Map barrierControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map barrierControlbarrierControlGoToPercentCommandParams = new LinkedHashMap(); + CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = new CommandParameterInfo("percentOpen", Integer.class); + barrierControlbarrierControlGoToPercentCommandParams.put("percentOpen",barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); + + InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .barrierControlGoToPercent((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("percentOpen") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + barrierControlbarrierControlGoToPercentCommandParams + ); + barrierControlClusterInteractionInfoMap.put("barrierControlGoToPercent", barrierControlbarrierControlGoToPercentInteractionInfo); + Map barrierControlbarrierControlStopCommandParams = new LinkedHashMap(); + InteractionInfo barrierControlbarrierControlStopInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .barrierControlStop((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + barrierControlbarrierControlStopCommandParams + ); + barrierControlClusterInteractionInfoMap.put("barrierControlStop", barrierControlbarrierControlStopInteractionInfo); + commandMap.put("barrierControl", barrierControlClusterInteractionInfoMap); + Map basicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("basic", basicClusterInteractionInfoMap); + Map binaryInputBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("binaryInputBasic", binaryInputBasicClusterInteractionInfoMap); + Map bindingClusterInteractionInfoMap = new LinkedHashMap<>(); + Map bindingbindCommandParams = new LinkedHashMap(); + CommandParameterInfo bindingbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); + bindingbindCommandParams.put("nodeId",bindingbindnodeIdCommandParameterInfo); + + CommandParameterInfo bindingbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + bindingbindCommandParams.put("groupId",bindingbindgroupIdCommandParameterInfo); + + CommandParameterInfo bindingbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); + bindingbindCommandParams.put("endpointId",bindingbindendpointIdCommandParameterInfo); + + CommandParameterInfo bindingbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); + bindingbindCommandParams.put("clusterId",bindingbindclusterIdCommandParameterInfo); + + InteractionInfo bindingbindInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .bind((DefaultClusterCallback) callback + , (Long) + commandArguments.get("nodeId") + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("endpointId") + , (Long) + commandArguments.get("clusterId") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bindingbindCommandParams + ); + bindingClusterInteractionInfoMap.put("bind", bindingbindInteractionInfo); + Map bindingunbindCommandParams = new LinkedHashMap(); + CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); + bindingunbindCommandParams.put("nodeId",bindingunbindnodeIdCommandParameterInfo); + + CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + bindingunbindCommandParams.put("groupId",bindingunbindgroupIdCommandParameterInfo); + + CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); + bindingunbindCommandParams.put("endpointId",bindingunbindendpointIdCommandParameterInfo); + + CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); + bindingunbindCommandParams.put("clusterId",bindingunbindclusterIdCommandParameterInfo); + + InteractionInfo bindingunbindInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .unbind((DefaultClusterCallback) callback + , (Long) + commandArguments.get("nodeId") + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("endpointId") + , (Long) + commandArguments.get("clusterId") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bindingunbindCommandParams + ); + bindingClusterInteractionInfoMap.put("unbind", bindingunbindInteractionInfo); + commandMap.put("binding", bindingClusterInteractionInfoMap); + Map booleanStateClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("booleanState", booleanStateClusterInteractionInfoMap); + Map bridgedActionsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map bridgedActionsdisableActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsdisableActionCommandParams.put("actionID",bridgedActionsdisableActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsdisableActionCommandParams.put("invokeID",bridgedActionsdisableActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsdisableActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .disableAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsdisableActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("disableAction", bridgedActionsdisableActionInteractionInfo); + Map bridgedActionsdisableActionWithDurationCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsdisableActionWithDurationCommandParams.put("actionID",bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsdisableActionWithDurationCommandParams.put("invokeID",bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); + bridgedActionsdisableActionWithDurationCommandParams.put("duration",bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .disableActionWithDuration((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + , (Long) + commandArguments.get("duration") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsdisableActionWithDurationCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("disableActionWithDuration", bridgedActionsdisableActionWithDurationInteractionInfo); + Map bridgedActionsenableActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsenableActionCommandParams.put("actionID",bridgedActionsenableActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsenableActionCommandParams.put("invokeID",bridgedActionsenableActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsenableActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .enableAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsenableActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("enableAction", bridgedActionsenableActionInteractionInfo); + Map bridgedActionsenableActionWithDurationCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsenableActionWithDurationCommandParams.put("actionID",bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsenableActionWithDurationCommandParams.put("invokeID",bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); + bridgedActionsenableActionWithDurationCommandParams.put("duration",bridgedActionsenableActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .enableActionWithDuration((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + , (Long) + commandArguments.get("duration") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsenableActionWithDurationCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("enableActionWithDuration", bridgedActionsenableActionWithDurationInteractionInfo); + Map bridgedActionsinstantActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsinstantActionCommandParams.put("actionID",bridgedActionsinstantActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsinstantActionCommandParams.put("invokeID",bridgedActionsinstantActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsinstantActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .instantAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsinstantActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("instantAction", bridgedActionsinstantActionInteractionInfo); + Map bridgedActionsinstantActionWithTransitionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsinstantActionWithTransitionCommandParams.put("actionID",bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsinstantActionWithTransitionCommandParams.put("invokeID",bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + bridgedActionsinstantActionWithTransitionCommandParams.put("transitionTime",bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); + + InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .instantActionWithTransition((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + , (Integer) + commandArguments.get("transitionTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsinstantActionWithTransitionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("instantActionWithTransition", bridgedActionsinstantActionWithTransitionInteractionInfo); + Map bridgedActionspauseActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionspauseActionCommandParams.put("actionID",bridgedActionspauseActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionspauseActionCommandParams.put("invokeID",bridgedActionspauseActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionspauseActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .pauseAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionspauseActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("pauseAction", bridgedActionspauseActionInteractionInfo); + Map bridgedActionspauseActionWithDurationCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionspauseActionWithDurationCommandParams.put("actionID",bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionspauseActionWithDurationCommandParams.put("invokeID",bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); + bridgedActionspauseActionWithDurationCommandParams.put("duration",bridgedActionspauseActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .pauseActionWithDuration((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + , (Long) + commandArguments.get("duration") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionspauseActionWithDurationCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("pauseActionWithDuration", bridgedActionspauseActionWithDurationInteractionInfo); + Map bridgedActionsresumeActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsresumeActionCommandParams.put("actionID",bridgedActionsresumeActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsresumeActionCommandParams.put("invokeID",bridgedActionsresumeActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsresumeActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .resumeAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsresumeActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("resumeAction", bridgedActionsresumeActionInteractionInfo); + Map bridgedActionsstartActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstartActionCommandParams.put("actionID",bridgedActionsstartActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstartActionCommandParams.put("invokeID",bridgedActionsstartActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsstartActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .startAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstartActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("startAction", bridgedActionsstartActionInteractionInfo); + Map bridgedActionsstartActionWithDurationCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstartActionWithDurationCommandParams.put("actionID",bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstartActionWithDurationCommandParams.put("invokeID",bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); + bridgedActionsstartActionWithDurationCommandParams.put("duration",bridgedActionsstartActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .startActionWithDuration((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + , (Long) + commandArguments.get("duration") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstartActionWithDurationCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("startActionWithDuration", bridgedActionsstartActionWithDurationInteractionInfo); + Map bridgedActionsstopActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstopActionCommandParams.put("actionID",bridgedActionsstopActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstopActionCommandParams.put("invokeID",bridgedActionsstopActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsstopActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .stopAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstopActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("stopAction", bridgedActionsstopActionInteractionInfo); + commandMap.put("bridgedActions", bridgedActionsClusterInteractionInfoMap); + Map bridgedDeviceBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInteractionInfoMap); + Map channelClusterInteractionInfoMap = new LinkedHashMap<>(); + Map channelchangeChannelByNumberRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = new CommandParameterInfo("majorNumber", Integer.class); + channelchangeChannelByNumberRequestCommandParams.put("majorNumber",channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); + + CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = new CommandParameterInfo("minorNumber", Integer.class); + channelchangeChannelByNumberRequestCommandParams.put("minorNumber",channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); + + InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .changeChannelByNumberRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("majorNumber") + , (Integer) + commandArguments.get("minorNumber") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + channelchangeChannelByNumberRequestCommandParams + ); + channelClusterInteractionInfoMap.put("changeChannelByNumberRequest", channelchangeChannelByNumberRequestInteractionInfo); + Map channelchangeChannelRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = new CommandParameterInfo("match", String.class); + channelchangeChannelRequestCommandParams.put("match",channelchangeChannelRequestmatchCommandParameterInfo); + + InteractionInfo channelchangeChannelRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .changeChannelRequest((ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback + , (String) + commandArguments.get("match") + + ); + }, + () -> new DelegatedChangeChannelResponseCallback(), + channelchangeChannelRequestCommandParams + ); + channelClusterInteractionInfoMap.put("changeChannelRequest", channelchangeChannelRequestInteractionInfo); + Map channelskipChannelRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = new CommandParameterInfo("count", Integer.class); + channelskipChannelRequestCommandParams.put("count",channelskipChannelRequestcountCommandParameterInfo); + + InteractionInfo channelskipChannelRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .skipChannelRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("count") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + channelskipChannelRequestCommandParams + ); + channelClusterInteractionInfoMap.put("skipChannelRequest", channelskipChannelRequestInteractionInfo); + commandMap.put("channel", channelClusterInteractionInfoMap); + Map colorControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map colorControlcolorLoopSetCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = new CommandParameterInfo("updateFlags", Integer.class); + colorControlcolorLoopSetCommandParams.put("updateFlags",colorControlcolorLoopSetupdateFlagsCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = new CommandParameterInfo("action", Integer.class); + colorControlcolorLoopSetCommandParams.put("action",colorControlcolorLoopSetactionCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); + colorControlcolorLoopSetCommandParams.put("direction",colorControlcolorLoopSetdirectionCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = new CommandParameterInfo("time", Integer.class); + colorControlcolorLoopSetCommandParams.put("time",colorControlcolorLoopSettimeCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = new CommandParameterInfo("startHue", Integer.class); + colorControlcolorLoopSetCommandParams.put("startHue",colorControlcolorLoopSetstartHueCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlcolorLoopSetCommandParams.put("optionsMask",colorControlcolorLoopSetoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlcolorLoopSetCommandParams.put("optionsOverride",colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlcolorLoopSetInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .colorLoopSet((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("updateFlags") + , (Integer) + commandArguments.get("action") + , (Integer) + commandArguments.get("direction") + , (Integer) + commandArguments.get("time") + , (Integer) + commandArguments.get("startHue") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlcolorLoopSetCommandParams + ); + colorControlClusterInteractionInfoMap.put("colorLoopSet", colorControlcolorLoopSetInteractionInfo); + Map colorControlenhancedMoveHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + colorControlenhancedMoveHueCommandParams.put("moveMode",colorControlenhancedMoveHuemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + colorControlenhancedMoveHueCommandParams.put("rate",colorControlenhancedMoveHuerateCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveHueCommandParams.put("optionsMask",colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveHueCommandParams.put("optionsOverride",colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("enhancedMoveHue", colorControlenhancedMoveHueInteractionInfo); + Map colorControlenhancedMoveToHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); + colorControlenhancedMoveToHueCommandParams.put("enhancedHue",colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); + colorControlenhancedMoveToHueCommandParams.put("direction",colorControlenhancedMoveToHuedirectionCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedMoveToHueCommandParams.put("transitionTime",colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveToHueCommandParams.put("optionsMask",colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveToHueCommandParams.put("optionsOverride",colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveToHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveToHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("enhancedHue") + , (Integer) + commandArguments.get("direction") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveToHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("enhancedMoveToHue", colorControlenhancedMoveToHueInteractionInfo); + Map colorControlenhancedMoveToHueAndSaturationCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put("enhancedHue",colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put("saturation",colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put("transitionTime",colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsMask",colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveToHueAndSaturation((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("enhancedHue") + , (Integer) + commandArguments.get("saturation") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveToHueAndSaturationCommandParams + ); + colorControlClusterInteractionInfoMap.put("enhancedMoveToHueAndSaturation", colorControlenhancedMoveToHueAndSaturationInteractionInfo); + Map colorControlenhancedStepHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + colorControlenhancedStepHueCommandParams.put("stepMode",colorControlenhancedStepHuestepModeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + colorControlenhancedStepHueCommandParams.put("stepSize",colorControlenhancedStepHuestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedStepHueCommandParams.put("transitionTime",colorControlenhancedStepHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedStepHueCommandParams.put("optionsMask",colorControlenhancedStepHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedStepHueCommandParams.put("optionsOverride",colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedStepHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedStepHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedStepHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("enhancedStepHue", colorControlenhancedStepHueInteractionInfo); + Map colorControlmoveColorCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = new CommandParameterInfo("rateX", Integer.class); + colorControlmoveColorCommandParams.put("rateX",colorControlmoveColorrateXCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = new CommandParameterInfo("rateY", Integer.class); + colorControlmoveColorCommandParams.put("rateY",colorControlmoveColorrateYCommandParameterInfo); + + CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveColorCommandParams.put("optionsMask",colorControlmoveColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveColorCommandParams.put("optionsOverride",colorControlmoveColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveColorInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveColor((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("rateX") + , (Integer) + commandArguments.get("rateY") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveColorCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveColor", colorControlmoveColorInteractionInfo); + Map colorControlmoveColorTemperatureCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("moveMode",colorControlmoveColorTemperaturemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("rate",colorControlmoveColorTemperaturerateCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("optionsMask",colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("optionsOverride",colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveColorTemperatureInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveColorTemperature((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + , (Integer) + commandArguments.get("colorTemperatureMinimum") + , (Integer) + commandArguments.get("colorTemperatureMaximum") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveColorTemperatureCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveColorTemperature", colorControlmoveColorTemperatureInteractionInfo); + Map colorControlmoveHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveHueCommandParams.put("moveMode",colorControlmoveHuemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + colorControlmoveHueCommandParams.put("rate",colorControlmoveHuerateCommandParameterInfo); + + CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveHueCommandParams.put("optionsMask",colorControlmoveHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveHueCommandParams.put("optionsOverride",colorControlmoveHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveHue", colorControlmoveHueInteractionInfo); + Map colorControlmoveSaturationCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveSaturationCommandParams.put("moveMode",colorControlmoveSaturationmoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + colorControlmoveSaturationCommandParams.put("rate",colorControlmoveSaturationrateCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveSaturationCommandParams.put("optionsMask",colorControlmoveSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveSaturationCommandParams.put("optionsOverride",colorControlmoveSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveSaturationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveSaturation((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveSaturationCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveSaturation", colorControlmoveSaturationInteractionInfo); + Map colorControlmoveToColorCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = new CommandParameterInfo("colorX", Integer.class); + colorControlmoveToColorCommandParams.put("colorX",colorControlmoveToColorcolorXCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = new CommandParameterInfo("colorY", Integer.class); + colorControlmoveToColorCommandParams.put("colorY",colorControlmoveToColorcolorYCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToColorCommandParams.put("transitionTime",colorControlmoveToColortransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToColorCommandParams.put("optionsMask",colorControlmoveToColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToColorCommandParams.put("optionsOverride",colorControlmoveToColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToColorInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToColor((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("colorX") + , (Integer) + commandArguments.get("colorY") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToColorCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveToColor", colorControlmoveToColorInteractionInfo); + Map colorControlmoveToColorTemperatureCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = new CommandParameterInfo("colorTemperature", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put("colorTemperature",colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put("transitionTime",colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put("optionsMask",colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put("optionsOverride",colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToColorTemperature((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("colorTemperature") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToColorTemperatureCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveToColorTemperature", colorControlmoveToColorTemperatureInteractionInfo); + Map colorControlmoveToHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); + colorControlmoveToHueCommandParams.put("hue",colorControlmoveToHuehueCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); + colorControlmoveToHueCommandParams.put("direction",colorControlmoveToHuedirectionCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToHueCommandParams.put("transitionTime",colorControlmoveToHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToHueCommandParams.put("optionsMask",colorControlmoveToHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToHueCommandParams.put("optionsOverride",colorControlmoveToHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("hue") + , (Integer) + commandArguments.get("direction") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveToHue", colorControlmoveToHueInteractionInfo); + Map colorControlmoveToHueAndSaturationCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put("hue",colorControlmoveToHueAndSaturationhueCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put("saturation",colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put("transitionTime",colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put("optionsMask",colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToHueAndSaturation((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("hue") + , (Integer) + commandArguments.get("saturation") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToHueAndSaturationCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveToHueAndSaturation", colorControlmoveToHueAndSaturationInteractionInfo); + Map colorControlmoveToSaturationCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); + colorControlmoveToSaturationCommandParams.put("saturation",colorControlmoveToSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToSaturationCommandParams.put("transitionTime",colorControlmoveToSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToSaturationCommandParams.put("optionsMask",colorControlmoveToSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToSaturationCommandParams.put("optionsOverride",colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToSaturationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToSaturation((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("saturation") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToSaturationCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveToSaturation", colorControlmoveToSaturationInteractionInfo); + Map colorControlstepColorCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = new CommandParameterInfo("stepX", Integer.class); + colorControlstepColorCommandParams.put("stepX",colorControlstepColorstepXCommandParameterInfo); + + CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = new CommandParameterInfo("stepY", Integer.class); + colorControlstepColorCommandParams.put("stepY",colorControlstepColorstepYCommandParameterInfo); + + CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepColorCommandParams.put("transitionTime",colorControlstepColortransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepColorCommandParams.put("optionsMask",colorControlstepColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepColorCommandParams.put("optionsOverride",colorControlstepColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepColorInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepColor((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepX") + , (Integer) + commandArguments.get("stepY") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepColorCommandParams + ); + colorControlClusterInteractionInfoMap.put("stepColor", colorControlstepColorInteractionInfo); + Map colorControlstepColorTemperatureCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + colorControlstepColorTemperatureCommandParams.put("stepMode",colorControlstepColorTemperaturestepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + colorControlstepColorTemperatureCommandParams.put("stepSize",colorControlstepColorTemperaturestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepColorTemperatureCommandParams.put("transitionTime",colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); + colorControlstepColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); + colorControlstepColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepColorTemperatureCommandParams.put("optionsMask",colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepColorTemperatureCommandParams.put("optionsOverride",colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepColorTemperatureInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepColorTemperature((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("colorTemperatureMinimum") + , (Integer) + commandArguments.get("colorTemperatureMaximum") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepColorTemperatureCommandParams + ); + colorControlClusterInteractionInfoMap.put("stepColorTemperature", colorControlstepColorTemperatureInteractionInfo); + Map colorControlstepHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + colorControlstepHueCommandParams.put("stepMode",colorControlstepHuestepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + colorControlstepHueCommandParams.put("stepSize",colorControlstepHuestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepHueCommandParams.put("transitionTime",colorControlstepHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepHueCommandParams.put("optionsMask",colorControlstepHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepHueCommandParams.put("optionsOverride",colorControlstepHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("stepHue", colorControlstepHueInteractionInfo); + Map colorControlstepSaturationCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + colorControlstepSaturationCommandParams.put("stepMode",colorControlstepSaturationstepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + colorControlstepSaturationCommandParams.put("stepSize",colorControlstepSaturationstepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepSaturationCommandParams.put("transitionTime",colorControlstepSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepSaturationCommandParams.put("optionsMask",colorControlstepSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepSaturationCommandParams.put("optionsOverride",colorControlstepSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepSaturationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepSaturation((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepSaturationCommandParams + ); + colorControlClusterInteractionInfoMap.put("stepSaturation", colorControlstepSaturationInteractionInfo); + Map colorControlstopMoveStepCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlstopMoveStepCommandParams.put("optionsMask",colorControlstopMoveStepoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstopMoveStepCommandParams.put("optionsOverride",colorControlstopMoveStepoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstopMoveStepInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stopMoveStep((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstopMoveStepCommandParams + ); + colorControlClusterInteractionInfoMap.put("stopMoveStep", colorControlstopMoveStepInteractionInfo); + commandMap.put("colorControl", colorControlClusterInteractionInfoMap); + Map contentLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); + Map contentLauncherlaunchContentRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = new CommandParameterInfo("autoPlay", Boolean.class); + contentLauncherlaunchContentRequestCommandParams.put("autoPlay",contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); + + CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); + contentLauncherlaunchContentRequestCommandParams.put("data",contentLauncherlaunchContentRequestdataCommandParameterInfo); + + InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .launchContentRequest((ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback + , (Boolean) + commandArguments.get("autoPlay") + , (String) + commandArguments.get("data") + , (ArrayList) + commandArguments.get("search") + + ); + }, + () -> new DelegatedLaunchResponseCallback(), + contentLauncherlaunchContentRequestCommandParams + ); + contentLauncherClusterInteractionInfoMap.put("launchContentRequest", contentLauncherlaunchContentRequestInteractionInfo); + Map contentLauncherlaunchURLRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = new CommandParameterInfo("contentURL", String.class); + contentLauncherlaunchURLRequestCommandParams.put("contentURL",contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); + + CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = new CommandParameterInfo("displayString", String.class); + contentLauncherlaunchURLRequestCommandParams.put("displayString",contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); + + InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .launchURLRequest((ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback + , (String) + commandArguments.get("contentURL") + , (String) + commandArguments.get("displayString") + , (ChipStructs.ContentLauncherClusterBrandingInformation) + commandArguments.get("brandingInformation") + + ); + }, + () -> new DelegatedLaunchResponseCallback(), + contentLauncherlaunchURLRequestCommandParams + ); + contentLauncherClusterInteractionInfoMap.put("launchURLRequest", contentLauncherlaunchURLRequestInteractionInfo); + commandMap.put("contentLauncher", contentLauncherClusterInteractionInfoMap); + Map descriptorClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("descriptor", descriptorClusterInteractionInfoMap); + Map diagnosticLogsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map diagnosticLogsretrieveLogsRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = new CommandParameterInfo("intent", Integer.class); + diagnosticLogsretrieveLogsRequestCommandParams.put("intent",diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); + + CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = new CommandParameterInfo("requestedProtocol", Integer.class); + diagnosticLogsretrieveLogsRequestCommandParams.put("requestedProtocol",diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); + + CommandParameterInfo diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = new CommandParameterInfo("transferFileDesignator", byte[].class); + diagnosticLogsretrieveLogsRequestCommandParams.put("transferFileDesignator",diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); + + InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .retrieveLogsRequest((ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback) callback + , (Integer) + commandArguments.get("intent") + , (Integer) + commandArguments.get("requestedProtocol") + , (byte[]) + commandArguments.get("transferFileDesignator") + + ); + }, + () -> new DelegatedRetrieveLogsResponseCallback(), + diagnosticLogsretrieveLogsRequestCommandParams + ); + diagnosticLogsClusterInteractionInfoMap.put("retrieveLogsRequest", diagnosticLogsretrieveLogsRequestInteractionInfo); + commandMap.put("diagnosticLogs", diagnosticLogsClusterInteractionInfoMap); + Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); + Map doorLockclearCredentialCommandParams = new LinkedHashMap(); + InteractionInfo doorLockclearCredentialInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearCredential((DefaultClusterCallback) callback + , (ChipStructs.DoorLockClusterDlCredential) + commandArguments.get("credential") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearCredentialCommandParams + ); + doorLockClusterInteractionInfoMap.put("clearCredential", doorLockclearCredentialInteractionInfo); + Map doorLockclearUserCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockclearUserCommandParams.put("userIndex",doorLockclearUseruserIndexCommandParameterInfo); + + InteractionInfo doorLockclearUserInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearUser((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("userIndex") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearUserCommandParams + ); + doorLockClusterInteractionInfoMap.put("clearUser", doorLockclearUserInteractionInfo); + Map doorLockclearWeekDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); + doorLockclearWeekDayScheduleCommandParams.put("weekDayIndex",doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockclearWeekDayScheduleCommandParams.put("userIndex",doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearWeekDaySchedule((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("weekDayIndex") + , (Integer) + commandArguments.get("userIndex") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearWeekDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("clearWeekDaySchedule", doorLockclearWeekDayScheduleInteractionInfo); + Map doorLockclearYearDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); + doorLockclearYearDayScheduleCommandParams.put("yearDayIndex",doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockclearYearDayScheduleCommandParams.put("userIndex",doorLockclearYearDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockclearYearDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearYearDaySchedule((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("yearDayIndex") + , (Integer) + commandArguments.get("userIndex") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearYearDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("clearYearDaySchedule", doorLockclearYearDayScheduleInteractionInfo); + Map doorLockgetCredentialStatusCommandParams = new LinkedHashMap(); + InteractionInfo doorLockgetCredentialStatusInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getCredentialStatus((ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback + , (ChipStructs.DoorLockClusterDlCredential) + commandArguments.get("credential") + + ); + }, + () -> new DelegatedGetCredentialStatusResponseCallback(), + doorLockgetCredentialStatusCommandParams + ); + doorLockClusterInteractionInfoMap.put("getCredentialStatus", doorLockgetCredentialStatusInteractionInfo); + Map doorLockgetUserCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockgetUserCommandParams.put("userIndex",doorLockgetUseruserIndexCommandParameterInfo); + + InteractionInfo doorLockgetUserInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getUser((ChipClusters.DoorLockCluster.GetUserResponseCallback) callback + , (Integer) + commandArguments.get("userIndex") + + ); + }, + () -> new DelegatedGetUserResponseCallback(), + doorLockgetUserCommandParams + ); + doorLockClusterInteractionInfoMap.put("getUser", doorLockgetUserInteractionInfo); + Map doorLockgetWeekDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); + doorLockgetWeekDayScheduleCommandParams.put("weekDayIndex",doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockgetWeekDayScheduleCommandParams.put("userIndex",doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getWeekDaySchedule((ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback) callback + , (Integer) + commandArguments.get("weekDayIndex") + , (Integer) + commandArguments.get("userIndex") + + ); + }, + () -> new DelegatedGetWeekDayScheduleResponseCallback(), + doorLockgetWeekDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("getWeekDaySchedule", doorLockgetWeekDayScheduleInteractionInfo); + Map doorLockgetYearDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); + doorLockgetYearDayScheduleCommandParams.put("yearDayIndex",doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockgetYearDayScheduleCommandParams.put("userIndex",doorLockgetYearDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockgetYearDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getYearDaySchedule((ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback) callback + , (Integer) + commandArguments.get("yearDayIndex") + , (Integer) + commandArguments.get("userIndex") + + ); + }, + () -> new DelegatedGetYearDayScheduleResponseCallback(), + doorLockgetYearDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("getYearDaySchedule", doorLockgetYearDayScheduleInteractionInfo); + Map doorLocklockDoorCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); + doorLocklockDoorCommandParams.put("pinCode",doorLocklockDoorpinCodeCommandParameterInfo); + + InteractionInfo doorLocklockDoorInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .lockDoor((DefaultClusterCallback) callback + , (Optional) + commandArguments.get("pinCode") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocklockDoorCommandParams + ); + doorLockClusterInteractionInfoMap.put("lockDoor", doorLocklockDoorInteractionInfo); + Map doorLocksetCredentialCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); + doorLocksetCredentialCommandParams.put("operationType",doorLocksetCredentialoperationTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = new CommandParameterInfo("credentialData", byte[].class); + doorLocksetCredentialCommandParams.put("credentialData",doorLocksetCredentialcredentialDataCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLocksetCredentialCommandParams.put("userIndex",doorLocksetCredentialuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); + doorLocksetCredentialCommandParams.put("userStatus",doorLocksetCredentialuserStatusCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); + doorLocksetCredentialCommandParams.put("userType",doorLocksetCredentialuserTypeCommandParameterInfo); + + InteractionInfo doorLocksetCredentialInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setCredential((ChipClusters.DoorLockCluster.SetCredentialResponseCallback) callback + , (Integer) + commandArguments.get("operationType") + , (ChipStructs.DoorLockClusterDlCredential) + commandArguments.get("credential") + , (byte[]) + commandArguments.get("credentialData") + , (Integer) + commandArguments.get("userIndex") + , (Integer) + commandArguments.get("userStatus") + , (Integer) + commandArguments.get("userType") + , 10000 + ); + }, + () -> new DelegatedSetCredentialResponseCallback(), + doorLocksetCredentialCommandParams + ); + doorLockClusterInteractionInfoMap.put("setCredential", doorLocksetCredentialInteractionInfo); + Map doorLocksetUserCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); + doorLocksetUserCommandParams.put("operationType",doorLocksetUseroperationTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLocksetUserCommandParams.put("userIndex",doorLocksetUseruserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = new CommandParameterInfo("userName", String.class); + doorLocksetUserCommandParams.put("userName",doorLocksetUseruserNameCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = new CommandParameterInfo("userUniqueId", Long.class); + doorLocksetUserCommandParams.put("userUniqueId",doorLocksetUseruserUniqueIdCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); + doorLocksetUserCommandParams.put("userStatus",doorLocksetUseruserStatusCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); + doorLocksetUserCommandParams.put("userType",doorLocksetUseruserTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = new CommandParameterInfo("credentialRule", Integer.class); + doorLocksetUserCommandParams.put("credentialRule",doorLocksetUsercredentialRuleCommandParameterInfo); + + InteractionInfo doorLocksetUserInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setUser((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("operationType") + , (Integer) + commandArguments.get("userIndex") + , (String) + commandArguments.get("userName") + , (Long) + commandArguments.get("userUniqueId") + , (Integer) + commandArguments.get("userStatus") + , (Integer) + commandArguments.get("userType") + , (Integer) + commandArguments.get("credentialRule") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetUserCommandParams + ); + doorLockClusterInteractionInfoMap.put("setUser", doorLocksetUserInteractionInfo); + Map doorLocksetWeekDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("weekDayIndex",doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("userIndex",doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = new CommandParameterInfo("daysMask", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("daysMask",doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = new CommandParameterInfo("startHour", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("startHour",doorLocksetWeekDaySchedulestartHourCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = new CommandParameterInfo("startMinute", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("startMinute",doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = new CommandParameterInfo("endHour", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("endHour",doorLocksetWeekDayScheduleendHourCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = new CommandParameterInfo("endMinute", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("endMinute",doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); + + InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setWeekDaySchedule((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("weekDayIndex") + , (Integer) + commandArguments.get("userIndex") + , (Integer) + commandArguments.get("daysMask") + , (Integer) + commandArguments.get("startHour") + , (Integer) + commandArguments.get("startMinute") + , (Integer) + commandArguments.get("endHour") + , (Integer) + commandArguments.get("endMinute") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetWeekDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("setWeekDaySchedule", doorLocksetWeekDayScheduleInteractionInfo); + Map doorLocksetYearDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); + doorLocksetYearDayScheduleCommandParams.put("yearDayIndex",doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLocksetYearDayScheduleCommandParams.put("userIndex",doorLocksetYearDayScheduleuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = new CommandParameterInfo("localStartTime", Long.class); + doorLocksetYearDayScheduleCommandParams.put("localStartTime",doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = new CommandParameterInfo("localEndTime", Long.class); + doorLocksetYearDayScheduleCommandParams.put("localEndTime",doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); + + InteractionInfo doorLocksetYearDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setYearDaySchedule((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("yearDayIndex") + , (Integer) + commandArguments.get("userIndex") + , (Long) + commandArguments.get("localStartTime") + , (Long) + commandArguments.get("localEndTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetYearDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("setYearDaySchedule", doorLocksetYearDayScheduleInteractionInfo); + Map doorLockunlockDoorCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); + doorLockunlockDoorCommandParams.put("pinCode",doorLockunlockDoorpinCodeCommandParameterInfo); + + InteractionInfo doorLockunlockDoorInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .unlockDoor((DefaultClusterCallback) callback + , (Optional) + commandArguments.get("pinCode") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockunlockDoorCommandParams + ); + doorLockClusterInteractionInfoMap.put("unlockDoor", doorLockunlockDoorInteractionInfo); + Map doorLockunlockWithTimeoutCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = new CommandParameterInfo("timeout", Integer.class); + doorLockunlockWithTimeoutCommandParams.put("timeout",doorLockunlockWithTimeouttimeoutCommandParameterInfo); + + CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); + doorLockunlockWithTimeoutCommandParams.put("pinCode",doorLockunlockWithTimeoutpinCodeCommandParameterInfo); + + InteractionInfo doorLockunlockWithTimeoutInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .unlockWithTimeout((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("timeout") + , (Optional) + commandArguments.get("pinCode") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockunlockWithTimeoutCommandParams + ); + doorLockClusterInteractionInfoMap.put("unlockWithTimeout", doorLockunlockWithTimeoutInteractionInfo); + commandMap.put("doorLock", doorLockClusterInteractionInfoMap); + Map electricalMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("electricalMeasurement", electricalMeasurementClusterInteractionInfoMap); + Map ethernetNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map ethernetNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); + InteractionInfo ethernetNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + ethernetNetworkDiagnosticsresetCountsCommandParams + ); + ethernetNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", ethernetNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); + Map fixedLabelClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("fixedLabel", fixedLabelClusterInteractionInfoMap); + Map flowMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("flowMeasurement", flowMeasurementClusterInteractionInfoMap); + Map generalCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); + Map generalCommissioningarmFailSafeCommandParams = new LinkedHashMap(); + CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = new CommandParameterInfo("expiryLengthSeconds", Integer.class); + generalCommissioningarmFailSafeCommandParams.put("expiryLengthSeconds",generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); + + CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + generalCommissioningarmFailSafeCommandParams.put("breadcrumb",generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); + + CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); + generalCommissioningarmFailSafeCommandParams.put("timeoutMs",generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); + + InteractionInfo generalCommissioningarmFailSafeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .armFailSafe((ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback) callback + , (Integer) + commandArguments.get("expiryLengthSeconds") + , (Long) + commandArguments.get("breadcrumb") + , (Long) + commandArguments.get("timeoutMs") + + ); + }, + () -> new DelegatedArmFailSafeResponseCallback(), + generalCommissioningarmFailSafeCommandParams + ); + generalCommissioningClusterInteractionInfoMap.put("armFailSafe", generalCommissioningarmFailSafeInteractionInfo); + Map generalCommissioningcommissioningCompleteCommandParams = new LinkedHashMap(); + InteractionInfo generalCommissioningcommissioningCompleteInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .commissioningComplete((ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback) callback + + ); + }, + () -> new DelegatedCommissioningCompleteResponseCallback(), + generalCommissioningcommissioningCompleteCommandParams + ); + generalCommissioningClusterInteractionInfoMap.put("commissioningComplete", generalCommissioningcommissioningCompleteInteractionInfo); + Map generalCommissioningsetRegulatoryConfigCommandParams = new LinkedHashMap(); + CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = new CommandParameterInfo("location", Integer.class); + generalCommissioningsetRegulatoryConfigCommandParams.put("location",generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = new CommandParameterInfo("countryCode", String.class); + generalCommissioningsetRegulatoryConfigCommandParams.put("countryCode",generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + generalCommissioningsetRegulatoryConfigCommandParams.put("breadcrumb",generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); + generalCommissioningsetRegulatoryConfigCommandParams.put("timeoutMs",generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); + + InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .setRegulatoryConfig((ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback) callback + , (Integer) + commandArguments.get("location") + , (String) + commandArguments.get("countryCode") + , (Long) + commandArguments.get("breadcrumb") + , (Long) + commandArguments.get("timeoutMs") + + ); + }, + () -> new DelegatedSetRegulatoryConfigResponseCallback(), + generalCommissioningsetRegulatoryConfigCommandParams + ); + generalCommissioningClusterInteractionInfoMap.put("setRegulatoryConfig", generalCommissioningsetRegulatoryConfigInteractionInfo); + commandMap.put("generalCommissioning", generalCommissioningClusterInteractionInfoMap); + Map generalDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("generalDiagnostics", generalDiagnosticsClusterInteractionInfoMap); + Map groupKeyManagementClusterInteractionInfoMap = new LinkedHashMap<>(); + Map groupKeyManagementkeySetReadCommandParams = new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); + groupKeyManagementkeySetReadCommandParams.put("groupKeySetID",groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetReadInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetRead((ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback + , (Integer) + commandArguments.get("groupKeySetID") + + ); + }, + () -> new DelegatedKeySetReadResponseCallback(), + groupKeyManagementkeySetReadCommandParams + ); + groupKeyManagementClusterInteractionInfoMap.put("keySetRead", groupKeyManagementkeySetReadInteractionInfo); + Map groupKeyManagementkeySetReadAllIndicesCommandParams = new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = new CommandParameterInfo("groupKeySetIDs", ArrayList.class); + groupKeyManagementkeySetReadAllIndicesCommandParams.put("groupKeySetIDs",groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetReadAllIndices((ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) callback + , (ArrayList) + commandArguments.get("groupKeySetIDs") + + ); + }, + () -> new DelegatedKeySetReadAllIndicesResponseCallback(), + groupKeyManagementkeySetReadAllIndicesCommandParams + ); + groupKeyManagementClusterInteractionInfoMap.put("keySetReadAllIndices", groupKeyManagementkeySetReadAllIndicesInteractionInfo); + Map groupKeyManagementkeySetRemoveCommandParams = new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); + groupKeyManagementkeySetRemoveCommandParams.put("groupKeySetID",groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetRemove((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("groupKeySetID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + groupKeyManagementkeySetRemoveCommandParams + ); + groupKeyManagementClusterInteractionInfoMap.put("keySetRemove", groupKeyManagementkeySetRemoveInteractionInfo); + Map groupKeyManagementkeySetWriteCommandParams = new LinkedHashMap(); + InteractionInfo groupKeyManagementkeySetWriteInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetWrite((DefaultClusterCallback) callback + , (ChipStructs.GroupKeyManagementClusterGroupKeySet) + commandArguments.get("groupKeySet") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + groupKeyManagementkeySetWriteCommandParams + ); + groupKeyManagementClusterInteractionInfoMap.put("keySetWrite", groupKeyManagementkeySetWriteInteractionInfo); + commandMap.put("groupKeyManagement", groupKeyManagementClusterInteractionInfoMap); + Map groupsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map groupsaddGroupCommandParams = new LinkedHashMap(); + CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + groupsaddGroupCommandParams.put("groupId",groupsaddGroupgroupIdCommandParameterInfo); + + CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); + groupsaddGroupCommandParams.put("groupName",groupsaddGroupgroupNameCommandParameterInfo); + + InteractionInfo groupsaddGroupInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .addGroup((ChipClusters.GroupsCluster.AddGroupResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + , (String) + commandArguments.get("groupName") + + ); + }, + () -> new DelegatedAddGroupResponseCallback(), + groupsaddGroupCommandParams + ); + groupsClusterInteractionInfoMap.put("addGroup", groupsaddGroupInteractionInfo); + Map groupsaddGroupIfIdentifyingCommandParams = new LinkedHashMap(); + CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + groupsaddGroupIfIdentifyingCommandParams.put("groupId",groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); + + CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); + groupsaddGroupIfIdentifyingCommandParams.put("groupName",groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); + + InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .addGroupIfIdentifying((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("groupId") + , (String) + commandArguments.get("groupName") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + groupsaddGroupIfIdentifyingCommandParams + ); + groupsClusterInteractionInfoMap.put("addGroupIfIdentifying", groupsaddGroupIfIdentifyingInteractionInfo); + Map groupsgetGroupMembershipCommandParams = new LinkedHashMap(); + CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = new CommandParameterInfo("groupList", ArrayList.class); + groupsgetGroupMembershipCommandParams.put("groupList",groupsgetGroupMembershipgroupListCommandParameterInfo); + + InteractionInfo groupsgetGroupMembershipInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .getGroupMembership((ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback + , (ArrayList) + commandArguments.get("groupList") + + ); + }, + () -> new DelegatedGetGroupMembershipResponseCallback(), + groupsgetGroupMembershipCommandParams + ); + groupsClusterInteractionInfoMap.put("getGroupMembership", groupsgetGroupMembershipInteractionInfo); + Map groupsremoveAllGroupsCommandParams = new LinkedHashMap(); + InteractionInfo groupsremoveAllGroupsInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .removeAllGroups((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + groupsremoveAllGroupsCommandParams + ); + groupsClusterInteractionInfoMap.put("removeAllGroups", groupsremoveAllGroupsInteractionInfo); + Map groupsremoveGroupCommandParams = new LinkedHashMap(); + CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + groupsremoveGroupCommandParams.put("groupId",groupsremoveGroupgroupIdCommandParameterInfo); + + InteractionInfo groupsremoveGroupInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .removeGroup((ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + + ); + }, + () -> new DelegatedRemoveGroupResponseCallback(), + groupsremoveGroupCommandParams + ); + groupsClusterInteractionInfoMap.put("removeGroup", groupsremoveGroupInteractionInfo); + Map groupsviewGroupCommandParams = new LinkedHashMap(); + CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + groupsviewGroupCommandParams.put("groupId",groupsviewGroupgroupIdCommandParameterInfo); + + InteractionInfo groupsviewGroupInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .viewGroup((ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + + ); + }, + () -> new DelegatedViewGroupResponseCallback(), + groupsviewGroupCommandParams + ); + groupsClusterInteractionInfoMap.put("viewGroup", groupsviewGroupInteractionInfo); + commandMap.put("groups", groupsClusterInteractionInfoMap); + Map identifyClusterInteractionInfoMap = new LinkedHashMap<>(); + Map identifyidentifyCommandParams = new LinkedHashMap(); + CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("identifyTime", Integer.class); + identifyidentifyCommandParams.put("identifyTime",identifyidentifyidentifyTimeCommandParameterInfo); + + InteractionInfo identifyidentifyInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .identify((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("identifyTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + identifyidentifyCommandParams + ); + identifyClusterInteractionInfoMap.put("identify", identifyidentifyInteractionInfo); + Map identifyidentifyQueryCommandParams = new LinkedHashMap(); + InteractionInfo identifyidentifyQueryInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .identifyQuery((ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback + + ); + }, + () -> new DelegatedIdentifyQueryResponseCallback(), + identifyidentifyQueryCommandParams + ); + identifyClusterInteractionInfoMap.put("identifyQuery", identifyidentifyQueryInteractionInfo); + Map identifytriggerEffectCommandParams = new LinkedHashMap(); + CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = new CommandParameterInfo("effectIdentifier", Integer.class); + identifytriggerEffectCommandParams.put("effectIdentifier",identifytriggerEffecteffectIdentifierCommandParameterInfo); + + CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); + identifytriggerEffectCommandParams.put("effectVariant",identifytriggerEffecteffectVariantCommandParameterInfo); + + InteractionInfo identifytriggerEffectInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .triggerEffect((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("effectIdentifier") + , (Integer) + commandArguments.get("effectVariant") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + identifytriggerEffectCommandParams + ); + identifyClusterInteractionInfoMap.put("triggerEffect", identifytriggerEffectInteractionInfo); + commandMap.put("identify", identifyClusterInteractionInfoMap); + Map illuminanceMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInteractionInfoMap); + Map keypadInputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map keypadInputsendKeyRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = new CommandParameterInfo("keyCode", Integer.class); + keypadInputsendKeyRequestCommandParams.put("keyCode",keypadInputsendKeyRequestkeyCodeCommandParameterInfo); + + InteractionInfo keypadInputsendKeyRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .sendKeyRequest((ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback + , (Integer) + commandArguments.get("keyCode") + + ); + }, + () -> new DelegatedSendKeyResponseCallback(), + keypadInputsendKeyRequestCommandParams + ); + keypadInputClusterInteractionInfoMap.put("sendKeyRequest", keypadInputsendKeyRequestInteractionInfo); + commandMap.put("keypadInput", keypadInputClusterInteractionInfoMap); + Map levelControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map levelControlmoveCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + levelControlmoveCommandParams.put("moveMode",levelControlmovemoveModeCommandParameterInfo); + + CommandParameterInfo levelControlmoverateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + levelControlmoveCommandParams.put("rate",levelControlmoverateCommandParameterInfo); + + CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); + levelControlmoveCommandParams.put("optionMask",levelControlmoveoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); + levelControlmoveCommandParams.put("optionOverride",levelControlmoveoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlmoveInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .move((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + , (Integer) + commandArguments.get("optionMask") + , (Integer) + commandArguments.get("optionOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveCommandParams + ); + levelControlClusterInteractionInfoMap.put("move", levelControlmoveInteractionInfo); + Map levelControlmoveToLevelCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); + levelControlmoveToLevelCommandParams.put("level",levelControlmoveToLevellevelCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + levelControlmoveToLevelCommandParams.put("transitionTime",levelControlmoveToLeveltransitionTimeCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); + levelControlmoveToLevelCommandParams.put("optionMask",levelControlmoveToLeveloptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); + levelControlmoveToLevelCommandParams.put("optionOverride",levelControlmoveToLeveloptionOverrideCommandParameterInfo); + + InteractionInfo levelControlmoveToLevelInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveToLevel((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("level") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionMask") + , (Integer) + commandArguments.get("optionOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveToLevelCommandParams + ); + levelControlClusterInteractionInfoMap.put("moveToLevel", levelControlmoveToLevelInteractionInfo); + Map levelControlmoveToLevelWithOnOffCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); + levelControlmoveToLevelWithOnOffCommandParams.put("level",levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + levelControlmoveToLevelWithOnOffCommandParams.put("transitionTime",levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); + + InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveToLevelWithOnOff((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("level") + , (Integer) + commandArguments.get("transitionTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveToLevelWithOnOffCommandParams + ); + levelControlClusterInteractionInfoMap.put("moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffInteractionInfo); + Map levelControlmoveWithOnOffCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + levelControlmoveWithOnOffCommandParams.put("moveMode",levelControlmoveWithOnOffmoveModeCommandParameterInfo); + + CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + levelControlmoveWithOnOffCommandParams.put("rate",levelControlmoveWithOnOffrateCommandParameterInfo); + + InteractionInfo levelControlmoveWithOnOffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveWithOnOff((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveWithOnOffCommandParams + ); + levelControlClusterInteractionInfoMap.put("moveWithOnOff", levelControlmoveWithOnOffInteractionInfo); + Map levelControlstepCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlstepstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + levelControlstepCommandParams.put("stepMode",levelControlstepstepModeCommandParameterInfo); + + CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + levelControlstepCommandParams.put("stepSize",levelControlstepstepSizeCommandParameterInfo); + + CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + levelControlstepCommandParams.put("transitionTime",levelControlsteptransitionTimeCommandParameterInfo); + + CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); + levelControlstepCommandParams.put("optionMask",levelControlstepoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); + levelControlstepCommandParams.put("optionOverride",levelControlstepoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlstepInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .step((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionMask") + , (Integer) + commandArguments.get("optionOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstepCommandParams + ); + levelControlClusterInteractionInfoMap.put("step", levelControlstepInteractionInfo); + Map levelControlstepWithOnOffCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + levelControlstepWithOnOffCommandParams.put("stepMode",levelControlstepWithOnOffstepModeCommandParameterInfo); + + CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + levelControlstepWithOnOffCommandParams.put("stepSize",levelControlstepWithOnOffstepSizeCommandParameterInfo); + + CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + levelControlstepWithOnOffCommandParams.put("transitionTime",levelControlstepWithOnOfftransitionTimeCommandParameterInfo); + + InteractionInfo levelControlstepWithOnOffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stepWithOnOff((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstepWithOnOffCommandParams + ); + levelControlClusterInteractionInfoMap.put("stepWithOnOff", levelControlstepWithOnOffInteractionInfo); + Map levelControlstopCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); + levelControlstopCommandParams.put("optionMask",levelControlstopoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); + levelControlstopCommandParams.put("optionOverride",levelControlstopoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlstopInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stop((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("optionMask") + , (Integer) + commandArguments.get("optionOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstopCommandParams + ); + levelControlClusterInteractionInfoMap.put("stop", levelControlstopInteractionInfo); + Map levelControlstopWithOnOffCommandParams = new LinkedHashMap(); + InteractionInfo levelControlstopWithOnOffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stopWithOnOff((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstopWithOnOffCommandParams + ); + levelControlClusterInteractionInfoMap.put("stopWithOnOff", levelControlstopWithOnOffInteractionInfo); + commandMap.put("levelControl", levelControlClusterInteractionInfoMap); + Map localizationConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("localizationConfiguration", localizationConfigurationClusterInteractionInfoMap); + Map lowPowerClusterInteractionInfoMap = new LinkedHashMap<>(); + Map lowPowersleepCommandParams = new LinkedHashMap(); + InteractionInfo lowPowersleepInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .sleep((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + lowPowersleepCommandParams + ); + lowPowerClusterInteractionInfoMap.put("sleep", lowPowersleepInteractionInfo); + commandMap.put("lowPower", lowPowerClusterInteractionInfoMap); + Map mediaInputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map mediaInputhideInputStatusRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaInputhideInputStatusRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .hideInputStatusRequest((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputhideInputStatusRequestCommandParams + ); + mediaInputClusterInteractionInfoMap.put("hideInputStatusRequest", mediaInputhideInputStatusRequestInteractionInfo); + Map mediaInputrenameInputRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); + mediaInputrenameInputRequestCommandParams.put("index",mediaInputrenameInputRequestindexCommandParameterInfo); + + CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); + mediaInputrenameInputRequestCommandParams.put("name",mediaInputrenameInputRequestnameCommandParameterInfo); + + InteractionInfo mediaInputrenameInputRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .renameInputRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("index") + , (String) + commandArguments.get("name") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputrenameInputRequestCommandParams + ); + mediaInputClusterInteractionInfoMap.put("renameInputRequest", mediaInputrenameInputRequestInteractionInfo); + Map mediaInputselectInputRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); + mediaInputselectInputRequestCommandParams.put("index",mediaInputselectInputRequestindexCommandParameterInfo); + + InteractionInfo mediaInputselectInputRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .selectInputRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("index") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputselectInputRequestCommandParams + ); + mediaInputClusterInteractionInfoMap.put("selectInputRequest", mediaInputselectInputRequestInteractionInfo); + Map mediaInputshowInputStatusRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaInputshowInputStatusRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .showInputStatusRequest((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputshowInputStatusRequestCommandParams + ); + mediaInputClusterInteractionInfoMap.put("showInputStatusRequest", mediaInputshowInputStatusRequestInteractionInfo); + commandMap.put("mediaInput", mediaInputClusterInteractionInfoMap); + Map mediaPlaybackClusterInteractionInfoMap = new LinkedHashMap<>(); + Map mediaPlaybackfastForwardRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackfastForwardRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .fastForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackfastForwardRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("fastForwardRequest", mediaPlaybackfastForwardRequestInteractionInfo); + Map mediaPlaybacknextRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybacknextRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .nextRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybacknextRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("nextRequest", mediaPlaybacknextRequestInteractionInfo); + Map mediaPlaybackpauseRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackpauseRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .pauseRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackpauseRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("pauseRequest", mediaPlaybackpauseRequestInteractionInfo); + Map mediaPlaybackplayRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackplayRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .playRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackplayRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("playRequest", mediaPlaybackplayRequestInteractionInfo); + Map mediaPlaybackpreviousRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackpreviousRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .previousRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackpreviousRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("previousRequest", mediaPlaybackpreviousRequestInteractionInfo); + Map mediaPlaybackrewindRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackrewindRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .rewindRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackrewindRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("rewindRequest", mediaPlaybackrewindRequestInteractionInfo); + Map mediaPlaybackseekRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = new CommandParameterInfo("position", Long.class); + mediaPlaybackseekRequestCommandParams.put("position",mediaPlaybackseekRequestpositionCommandParameterInfo); + + InteractionInfo mediaPlaybackseekRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .seekRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + , (Long) + commandArguments.get("position") + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackseekRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("seekRequest", mediaPlaybackseekRequestInteractionInfo); + Map mediaPlaybackskipBackwardRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); + mediaPlaybackskipBackwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); + + InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .skipBackwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + , (Long) + commandArguments.get("deltaPositionMilliseconds") + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackskipBackwardRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("skipBackwardRequest", mediaPlaybackskipBackwardRequestInteractionInfo); + Map mediaPlaybackskipForwardRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); + mediaPlaybackskipForwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); + + InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .skipForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + , (Long) + commandArguments.get("deltaPositionMilliseconds") + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackskipForwardRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("skipForwardRequest", mediaPlaybackskipForwardRequestInteractionInfo); + Map mediaPlaybackstartOverRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackstartOverRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .startOverRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackstartOverRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("startOverRequest", mediaPlaybackstartOverRequestInteractionInfo); + Map mediaPlaybackstopRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackstopRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .stopRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackstopRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("stopRequest", mediaPlaybackstopRequestInteractionInfo); + commandMap.put("mediaPlayback", mediaPlaybackClusterInteractionInfoMap); + Map modeSelectClusterInteractionInfoMap = new LinkedHashMap<>(); + Map modeSelectchangeToModeCommandParams = new LinkedHashMap(); + CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = new CommandParameterInfo("newMode", Integer.class); + modeSelectchangeToModeCommandParams.put("newMode",modeSelectchangeToModenewModeCommandParameterInfo); + + InteractionInfo modeSelectchangeToModeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .changeToMode((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("newMode") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + modeSelectchangeToModeCommandParams + ); + modeSelectClusterInteractionInfoMap.put("changeToMode", modeSelectchangeToModeInteractionInfo); + commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); + Map networkCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); + Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = new CommandParameterInfo("operationalDataset", byte[].class); + networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("operationalDataset",networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .addOrUpdateThreadNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback + , (byte[]) + commandArguments.get("operationalDataset") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningaddOrUpdateThreadNetworkCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("addOrUpdateThreadNetwork", networkCommissioningaddOrUpdateThreadNetworkInteractionInfo); + Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("ssid",networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = new CommandParameterInfo("credentials", byte[].class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("credentials",networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .addOrUpdateWiFiNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback + , (byte[]) + commandArguments.get("ssid") + , (byte[]) + commandArguments.get("credentials") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningaddOrUpdateWiFiNetworkCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("addOrUpdateWiFiNetwork", networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo); + Map networkCommissioningconnectNetworkCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); + networkCommissioningconnectNetworkCommandParams.put("networkID",networkCommissioningconnectNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningconnectNetworkCommandParams.put("breadcrumb",networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningconnectNetworkInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .connectNetwork((ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback) callback + , (byte[]) + commandArguments.get("networkID") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedConnectNetworkResponseCallback(), + networkCommissioningconnectNetworkCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("connectNetwork", networkCommissioningconnectNetworkInteractionInfo); + Map networkCommissioningremoveNetworkCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); + networkCommissioningremoveNetworkCommandParams.put("networkID",networkCommissioningremoveNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningremoveNetworkCommandParams.put("breadcrumb",networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningremoveNetworkInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .removeNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback + , (byte[]) + commandArguments.get("networkID") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningremoveNetworkCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("removeNetwork", networkCommissioningremoveNetworkInteractionInfo); + Map networkCommissioningreorderNetworkCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); + networkCommissioningreorderNetworkCommandParams.put("networkID",networkCommissioningreorderNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = new CommandParameterInfo("networkIndex", Integer.class); + networkCommissioningreorderNetworkCommandParams.put("networkIndex",networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); + + CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningreorderNetworkCommandParams.put("breadcrumb",networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningreorderNetworkInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .reorderNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback + , (byte[]) + commandArguments.get("networkID") + , (Integer) + commandArguments.get("networkIndex") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningreorderNetworkCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("reorderNetwork", networkCommissioningreorderNetworkInteractionInfo); + Map networkCommissioningscanNetworksCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); + networkCommissioningscanNetworksCommandParams.put("ssid",networkCommissioningscanNetworksssidCommandParameterInfo); + + CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningscanNetworksCommandParams.put("breadcrumb",networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningscanNetworksInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .scanNetworks((ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback) callback + , (byte[]) + commandArguments.get("ssid") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedScanNetworksResponseCallback(), + networkCommissioningscanNetworksCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("scanNetworks", networkCommissioningscanNetworksInteractionInfo); + commandMap.put("networkCommissioning", networkCommissioningClusterInteractionInfoMap); + Map otaSoftwareUpdateProviderClusterInteractionInfoMap = new LinkedHashMap<>(); + Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("updateToken",otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = new CommandParameterInfo("newVersion", Long.class); + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("newVersion",otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .applyUpdateRequest((ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback) callback + , (byte[]) + commandArguments.get("updateToken") + , (Long) + commandArguments.get("newVersion") + + ); + }, + () -> new DelegatedApplyUpdateResponseCallback(), + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams + ); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put("applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo); + Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = new LinkedHashMap(); + CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("updateToken",otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("softwareVersion",otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .notifyUpdateApplied((DefaultClusterCallback) callback + , (byte[]) + commandArguments.get("updateToken") + , (Long) + commandArguments.get("softwareVersion") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams + ); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put("notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo); + Map otaSoftwareUpdateProviderqueryImageCommandParams = new LinkedHashMap(); + CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("vendorId",otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = new CommandParameterInfo("productId", Integer.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("productId",otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("softwareVersion",otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = new CommandParameterInfo("protocolsSupported", ArrayList.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("protocolsSupported",otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = new CommandParameterInfo("hardwareVersion", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("hardwareVersion",otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = new CommandParameterInfo("location", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("location",otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = new CommandParameterInfo("requestorCanConsent", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("requestorCanConsent",otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = new CommandParameterInfo("metadataForProvider", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("metadataForProvider",otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .queryImage((ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback) callback + , (Integer) + commandArguments.get("vendorId") + , (Integer) + commandArguments.get("productId") + , (Long) + commandArguments.get("softwareVersion") + , (ArrayList) + commandArguments.get("protocolsSupported") + , (Optional) + commandArguments.get("hardwareVersion") + , (Optional) + commandArguments.get("location") + , (Optional) + commandArguments.get("requestorCanConsent") + , (Optional) + commandArguments.get("metadataForProvider") + + ); + }, + () -> new DelegatedQueryImageResponseCallback(), + otaSoftwareUpdateProviderqueryImageCommandParams + ); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put("queryImage", otaSoftwareUpdateProviderqueryImageInteractionInfo); + commandMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInteractionInfoMap); + Map otaSoftwareUpdateRequestorClusterInteractionInfoMap = new LinkedHashMap<>(); + Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = new LinkedHashMap(); + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = new CommandParameterInfo("providerNodeId", Long.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("providerNodeId",otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("vendorId",otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = new CommandParameterInfo("announcementReason", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("announcementReason",otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = new CommandParameterInfo("metadataForNode", Optional.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("metadataForNode",otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = new CommandParameterInfo("endpoint", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("endpoint",otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .announceOtaProvider((DefaultClusterCallback) callback + , (Long) + commandArguments.get("providerNodeId") + , (Integer) + commandArguments.get("vendorId") + , (Integer) + commandArguments.get("announcementReason") + , (Optional) + commandArguments.get("metadataForNode") + , (Integer) + commandArguments.get("endpoint") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams + ); + otaSoftwareUpdateRequestorClusterInteractionInfoMap.put("announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo); + commandMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInteractionInfoMap); + Map occupancySensingClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("occupancySensing", occupancySensingClusterInteractionInfoMap); + Map onOffClusterInteractionInfoMap = new LinkedHashMap<>(); + Map onOffoffCommandParams = new LinkedHashMap(); + InteractionInfo onOffoffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .off((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffoffCommandParams + ); + onOffClusterInteractionInfoMap.put("off", onOffoffInteractionInfo); + Map onOffoffWithEffectCommandParams = new LinkedHashMap(); + CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = new CommandParameterInfo("effectId", Integer.class); + onOffoffWithEffectCommandParams.put("effectId",onOffoffWithEffecteffectIdCommandParameterInfo); + + CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); + onOffoffWithEffectCommandParams.put("effectVariant",onOffoffWithEffecteffectVariantCommandParameterInfo); + + InteractionInfo onOffoffWithEffectInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .offWithEffect((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("effectId") + , (Integer) + commandArguments.get("effectVariant") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffoffWithEffectCommandParams + ); + onOffClusterInteractionInfoMap.put("offWithEffect", onOffoffWithEffectInteractionInfo); + Map onOffonCommandParams = new LinkedHashMap(); + InteractionInfo onOffonInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .on((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonCommandParams + ); + onOffClusterInteractionInfoMap.put("on", onOffonInteractionInfo); + Map onOffonWithRecallGlobalSceneCommandParams = new LinkedHashMap(); + InteractionInfo onOffonWithRecallGlobalSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .onWithRecallGlobalScene((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonWithRecallGlobalSceneCommandParams + ); + onOffClusterInteractionInfoMap.put("onWithRecallGlobalScene", onOffonWithRecallGlobalSceneInteractionInfo); + Map onOffonWithTimedOffCommandParams = new LinkedHashMap(); + CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = new CommandParameterInfo("onOffControl", Integer.class); + onOffonWithTimedOffCommandParams.put("onOffControl",onOffonWithTimedOffonOffControlCommandParameterInfo); + + CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = new CommandParameterInfo("onTime", Integer.class); + onOffonWithTimedOffCommandParams.put("onTime",onOffonWithTimedOffonTimeCommandParameterInfo); + + CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("offWaitTime", Integer.class); + onOffonWithTimedOffCommandParams.put("offWaitTime",onOffonWithTimedOffoffWaitTimeCommandParameterInfo); + + InteractionInfo onOffonWithTimedOffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .onWithTimedOff((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("onOffControl") + , (Integer) + commandArguments.get("onTime") + , (Integer) + commandArguments.get("offWaitTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonWithTimedOffCommandParams + ); + onOffClusterInteractionInfoMap.put("onWithTimedOff", onOffonWithTimedOffInteractionInfo); + Map onOfftoggleCommandParams = new LinkedHashMap(); + InteractionInfo onOfftoggleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .toggle((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOfftoggleCommandParams + ); + onOffClusterInteractionInfoMap.put("toggle", onOfftoggleInteractionInfo); + commandMap.put("onOff", onOffClusterInteractionInfoMap); + Map onOffSwitchConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInteractionInfoMap); + Map operationalCredentialsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map operationalCredentialsaddNOCCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); + operationalCredentialsaddNOCCommandParams.put("NOCValue",operationalCredentialsaddNOCNOCValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); + operationalCredentialsaddNOCCommandParams.put("ICACValue",operationalCredentialsaddNOCICACValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = new CommandParameterInfo("IPKValue", byte[].class); + operationalCredentialsaddNOCCommandParams.put("IPKValue",operationalCredentialsaddNOCIPKValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = new CommandParameterInfo("caseAdminNode", Long.class); + operationalCredentialsaddNOCCommandParams.put("caseAdminNode",operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = new CommandParameterInfo("adminVendorId", Integer.class); + operationalCredentialsaddNOCCommandParams.put("adminVendorId",operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); + + InteractionInfo operationalCredentialsaddNOCInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .addNOC((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback + , (byte[]) + commandArguments.get("NOCValue") + , (Optional) + commandArguments.get("ICACValue") + , (byte[]) + commandArguments.get("IPKValue") + , (Long) + commandArguments.get("caseAdminNode") + , (Integer) + commandArguments.get("adminVendorId") + + ); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsaddNOCCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("addNOC", operationalCredentialsaddNOCInteractionInfo); + Map operationalCredentialsaddTrustedRootCertificateCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = new CommandParameterInfo("rootCertificate", byte[].class); + operationalCredentialsaddTrustedRootCertificateCommandParams.put("rootCertificate",operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); + + InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .addTrustedRootCertificate((DefaultClusterCallback) callback + , (byte[]) + commandArguments.get("rootCertificate") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + operationalCredentialsaddTrustedRootCertificateCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("addTrustedRootCertificate", operationalCredentialsaddTrustedRootCertificateInteractionInfo); + Map operationalCredentialsattestationRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = new CommandParameterInfo("attestationNonce", byte[].class); + operationalCredentialsattestationRequestCommandParams.put("attestationNonce",operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); + + InteractionInfo operationalCredentialsattestationRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .attestationRequest((ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) callback + , (byte[]) + commandArguments.get("attestationNonce") + + ); + }, + () -> new DelegatedAttestationResponseCallback(), + operationalCredentialsattestationRequestCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("attestationRequest", operationalCredentialsattestationRequestInteractionInfo); + Map operationalCredentialscertificateChainRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = new CommandParameterInfo("certificateType", Integer.class); + operationalCredentialscertificateChainRequestCommandParams.put("certificateType",operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); + + InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .certificateChainRequest((ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) callback + , (Integer) + commandArguments.get("certificateType") + + ); + }, + () -> new DelegatedCertificateChainResponseCallback(), + operationalCredentialscertificateChainRequestCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("certificateChainRequest", operationalCredentialscertificateChainRequestInteractionInfo); + Map operationalCredentialsopCSRRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = new CommandParameterInfo("CSRNonce", byte[].class); + operationalCredentialsopCSRRequestCommandParams.put("CSRNonce",operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); + + InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .opCSRRequest((ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback + , (byte[]) + commandArguments.get("CSRNonce") + + ); + }, + () -> new DelegatedOpCSRResponseCallback(), + operationalCredentialsopCSRRequestCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("opCSRRequest", operationalCredentialsopCSRRequestInteractionInfo); + Map operationalCredentialsremoveFabricCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = new CommandParameterInfo("fabricIndex", Integer.class); + operationalCredentialsremoveFabricCommandParams.put("fabricIndex",operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); + + InteractionInfo operationalCredentialsremoveFabricInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .removeFabric((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback + , (Integer) + commandArguments.get("fabricIndex") + + ); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsremoveFabricCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("removeFabric", operationalCredentialsremoveFabricInteractionInfo); + Map operationalCredentialsremoveTrustedRootCertificateCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = new CommandParameterInfo("trustedRootIdentifier", byte[].class); + operationalCredentialsremoveTrustedRootCertificateCommandParams.put("trustedRootIdentifier",operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); + + InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .removeTrustedRootCertificate((DefaultClusterCallback) callback + , (byte[]) + commandArguments.get("trustedRootIdentifier") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + operationalCredentialsremoveTrustedRootCertificateCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("removeTrustedRootCertificate", operationalCredentialsremoveTrustedRootCertificateInteractionInfo); + Map operationalCredentialsupdateFabricLabelCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = new CommandParameterInfo("label", String.class); + operationalCredentialsupdateFabricLabelCommandParams.put("label",operationalCredentialsupdateFabricLabellabelCommandParameterInfo); + + InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .updateFabricLabel((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback + , (String) + commandArguments.get("label") + + ); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsupdateFabricLabelCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("updateFabricLabel", operationalCredentialsupdateFabricLabelInteractionInfo); + Map operationalCredentialsupdateNOCCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); + operationalCredentialsupdateNOCCommandParams.put("NOCValue",operationalCredentialsupdateNOCNOCValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); + operationalCredentialsupdateNOCCommandParams.put("ICACValue",operationalCredentialsupdateNOCICACValueCommandParameterInfo); + + InteractionInfo operationalCredentialsupdateNOCInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .updateNOC((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback + , (byte[]) + commandArguments.get("NOCValue") + , (Optional) + commandArguments.get("ICACValue") + + ); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsupdateNOCCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("updateNOC", operationalCredentialsupdateNOCInteractionInfo); + commandMap.put("operationalCredentials", operationalCredentialsClusterInteractionInfoMap); + Map powerSourceClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("powerSource", powerSourceClusterInteractionInfoMap); + Map powerSourceConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInteractionInfoMap); + Map pressureMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("pressureMeasurement", pressureMeasurementClusterInteractionInfoMap); + Map pumpConfigurationAndControlClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInteractionInfoMap); + Map relativeHumidityMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInteractionInfoMap); + Map scenesClusterInteractionInfoMap = new LinkedHashMap<>(); + Map scenesaddSceneCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesaddSceneCommandParams.put("groupId",scenesaddScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); + scenesaddSceneCommandParams.put("sceneId",scenesaddScenesceneIdCommandParameterInfo); + + CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + scenesaddSceneCommandParams.put("transitionTime",scenesaddScenetransitionTimeCommandParameterInfo); + + CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = new CommandParameterInfo("sceneName", String.class); + scenesaddSceneCommandParams.put("sceneName",scenesaddScenesceneNameCommandParameterInfo); + + InteractionInfo scenesaddSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .addScene((ChipClusters.ScenesCluster.AddSceneResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("sceneId") + , (Integer) + commandArguments.get("transitionTime") + , (String) + commandArguments.get("sceneName") + , (ArrayList) + commandArguments.get("extensionFieldSets") + + ); + }, + () -> new DelegatedAddSceneResponseCallback(), + scenesaddSceneCommandParams + ); + scenesClusterInteractionInfoMap.put("addScene", scenesaddSceneInteractionInfo); + Map scenesgetSceneMembershipCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesgetSceneMembershipCommandParams.put("groupId",scenesgetSceneMembershipgroupIdCommandParameterInfo); + + InteractionInfo scenesgetSceneMembershipInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .getSceneMembership((ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + + ); + }, + () -> new DelegatedGetSceneMembershipResponseCallback(), + scenesgetSceneMembershipCommandParams + ); + scenesClusterInteractionInfoMap.put("getSceneMembership", scenesgetSceneMembershipInteractionInfo); + Map scenesrecallSceneCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesrecallSceneCommandParams.put("groupId",scenesrecallScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); + scenesrecallSceneCommandParams.put("sceneId",scenesrecallScenesceneIdCommandParameterInfo); + + CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + scenesrecallSceneCommandParams.put("transitionTime",scenesrecallScenetransitionTimeCommandParameterInfo); + + InteractionInfo scenesrecallSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .recallScene((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("sceneId") + , (Integer) + commandArguments.get("transitionTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + scenesrecallSceneCommandParams + ); + scenesClusterInteractionInfoMap.put("recallScene", scenesrecallSceneInteractionInfo); + Map scenesremoveAllScenesCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesremoveAllScenesCommandParams.put("groupId",scenesremoveAllScenesgroupIdCommandParameterInfo); + + InteractionInfo scenesremoveAllScenesInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .removeAllScenes((ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + + ); + }, + () -> new DelegatedRemoveAllScenesResponseCallback(), + scenesremoveAllScenesCommandParams + ); + scenesClusterInteractionInfoMap.put("removeAllScenes", scenesremoveAllScenesInteractionInfo); + Map scenesremoveSceneCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesremoveSceneCommandParams.put("groupId",scenesremoveScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); + scenesremoveSceneCommandParams.put("sceneId",scenesremoveScenesceneIdCommandParameterInfo); + + InteractionInfo scenesremoveSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .removeScene((ChipClusters.ScenesCluster.RemoveSceneResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("sceneId") + + ); + }, + () -> new DelegatedRemoveSceneResponseCallback(), + scenesremoveSceneCommandParams + ); + scenesClusterInteractionInfoMap.put("removeScene", scenesremoveSceneInteractionInfo); + Map scenesstoreSceneCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesstoreSceneCommandParams.put("groupId",scenesstoreScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); + scenesstoreSceneCommandParams.put("sceneId",scenesstoreScenesceneIdCommandParameterInfo); + + InteractionInfo scenesstoreSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .storeScene((ChipClusters.ScenesCluster.StoreSceneResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("sceneId") + + ); + }, + () -> new DelegatedStoreSceneResponseCallback(), + scenesstoreSceneCommandParams + ); + scenesClusterInteractionInfoMap.put("storeScene", scenesstoreSceneInteractionInfo); + Map scenesviewSceneCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesviewSceneCommandParams.put("groupId",scenesviewScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); + scenesviewSceneCommandParams.put("sceneId",scenesviewScenesceneIdCommandParameterInfo); + + InteractionInfo scenesviewSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .viewScene((ChipClusters.ScenesCluster.ViewSceneResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("sceneId") + + ); + }, + () -> new DelegatedViewSceneResponseCallback(), + scenesviewSceneCommandParams + ); + scenesClusterInteractionInfoMap.put("viewScene", scenesviewSceneInteractionInfo); + commandMap.put("scenes", scenesClusterInteractionInfoMap); + Map softwareDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map softwareDiagnosticsresetWatermarksCommandParams = new LinkedHashMap(); + InteractionInfo softwareDiagnosticsresetWatermarksInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .resetWatermarks((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + softwareDiagnosticsresetWatermarksCommandParams + ); + softwareDiagnosticsClusterInteractionInfoMap.put("resetWatermarks", softwareDiagnosticsresetWatermarksInteractionInfo); + commandMap.put("softwareDiagnostics", softwareDiagnosticsClusterInteractionInfoMap); + Map switchClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("switch", switchClusterInteractionInfoMap); + Map targetNavigatorClusterInteractionInfoMap = new LinkedHashMap<>(); + Map targetNavigatornavigateTargetRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = new CommandParameterInfo("target", Integer.class); + targetNavigatornavigateTargetRequestCommandParams.put("target",targetNavigatornavigateTargetRequesttargetCommandParameterInfo); + + CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); + targetNavigatornavigateTargetRequestCommandParams.put("data",targetNavigatornavigateTargetRequestdataCommandParameterInfo); + + InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .navigateTargetRequest((ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback) callback + , (Integer) + commandArguments.get("target") + , (String) + commandArguments.get("data") + + ); + }, + () -> new DelegatedNavigateTargetResponseCallback(), + targetNavigatornavigateTargetRequestCommandParams + ); + targetNavigatorClusterInteractionInfoMap.put("navigateTargetRequest", targetNavigatornavigateTargetRequestInteractionInfo); + commandMap.put("targetNavigator", targetNavigatorClusterInteractionInfoMap); + Map temperatureMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); + Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); + Map testClustersimpleStructEchoRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustersimpleStructEchoRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .simpleStructEchoRequest((ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback + , (ChipStructs.TestClusterClusterSimpleStruct) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedSimpleStructResponseCallback(), + testClustersimpleStructEchoRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("simpleStructEchoRequest", testClustersimpleStructEchoRequestInteractionInfo); + Map testClustertestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .test((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestCommandParams + ); + testClusterClusterInteractionInfoMap.put("test", testClustertestInteractionInfo); + Map testClustertestAddArgumentsCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); + testClustertestAddArgumentsCommandParams.put("arg1",testClustertestAddArgumentsarg1CommandParameterInfo); + + CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); + testClustertestAddArgumentsCommandParams.put("arg2",testClustertestAddArgumentsarg2CommandParameterInfo); + + InteractionInfo testClustertestAddArgumentsInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testAddArguments((ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback) callback + , (Integer) + commandArguments.get("arg1") + , (Integer) + commandArguments.get("arg2") + + ); + }, + () -> new DelegatedTestAddArgumentsResponseCallback(), + testClustertestAddArgumentsCommandParams + ); + testClusterClusterInteractionInfoMap.put("testAddArguments", testClustertestAddArgumentsInteractionInfo); + Map testClustertestEmitTestEventRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); + testClustertestEmitTestEventRequestCommandParams.put("arg1",testClustertestEmitTestEventRequestarg1CommandParameterInfo); + + CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); + testClustertestEmitTestEventRequestCommandParams.put("arg2",testClustertestEmitTestEventRequestarg2CommandParameterInfo); + + CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = new CommandParameterInfo("arg3", Boolean.class); + testClustertestEmitTestEventRequestCommandParams.put("arg3",testClustertestEmitTestEventRequestarg3CommandParameterInfo); + + InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testEmitTestEventRequest((ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback) callback + , (Integer) + commandArguments.get("arg1") + , (Integer) + commandArguments.get("arg2") + , (Boolean) + commandArguments.get("arg3") + + ); + }, + () -> new DelegatedTestEmitTestEventResponseCallback(), + testClustertestEmitTestEventRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testEmitTestEventRequest", testClustertestEmitTestEventRequestInteractionInfo); + Map testClustertestEnumsRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); + testClustertestEnumsRequestCommandParams.put("arg1",testClustertestEnumsRequestarg1CommandParameterInfo); + + CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); + testClustertestEnumsRequestCommandParams.put("arg2",testClustertestEnumsRequestarg2CommandParameterInfo); + + InteractionInfo testClustertestEnumsRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testEnumsRequest((ChipClusters.TestClusterCluster.TestEnumsResponseCallback) callback + , (Integer) + commandArguments.get("arg1") + , (Integer) + commandArguments.get("arg2") + + ); + }, + () -> new DelegatedTestEnumsResponseCallback(), + testClustertestEnumsRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testEnumsRequest", testClustertestEnumsRequestInteractionInfo); + Map testClustertestListInt8UArgumentRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); + testClustertestListInt8UArgumentRequestCommandParams.put("arg1",testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListInt8UArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ArrayList) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListInt8UArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestInteractionInfo); + Map testClustertestListInt8UReverseRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); + testClustertestListInt8UReverseRequestCommandParams.put("arg1",testClustertestListInt8UReverseRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListInt8UReverseRequest((ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) callback + , (ArrayList) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedTestListInt8UReverseResponseCallback(), + testClustertestListInt8UReverseRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testListInt8UReverseRequest", testClustertestListInt8UReverseRequestInteractionInfo); + Map testClustertestListNestedStructListArgumentRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestListNestedStructListArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ArrayList) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListNestedStructListArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testListNestedStructListArgumentRequest", testClustertestListNestedStructListArgumentRequestInteractionInfo); + Map testClustertestListStructArgumentRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ArrayList) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListStructArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testListStructArgumentRequest", testClustertestListStructArgumentRequestInteractionInfo); + Map testClustertestNestedStructArgumentRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestNestedStructArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNestedStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ChipStructs.TestClusterClusterNestedStruct) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestNestedStructArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testNestedStructArgumentRequest", testClustertestNestedStructArgumentRequestInteractionInfo); + Map testClustertestNestedStructListArgumentRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestNestedStructListArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ChipStructs.TestClusterClusterNestedStructList) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestNestedStructListArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testNestedStructListArgumentRequest", testClustertestNestedStructListArgumentRequestInteractionInfo); + Map testClustertestNotHandledCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestNotHandledInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNotHandled((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestNotHandledCommandParams + ); + testClusterClusterInteractionInfoMap.put("testNotHandled", testClustertestNotHandledInteractionInfo); + Map testClustertestNullableOptionalRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); + testClustertestNullableOptionalRequestCommandParams.put("arg1",testClustertestNullableOptionalRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNullableOptionalRequest((ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) callback + , (Optional) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedTestNullableOptionalResponseCallback(), + testClustertestNullableOptionalRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testNullableOptionalRequest", testClustertestNullableOptionalRequestInteractionInfo); + Map testClustertestSimpleOptionalArgumentRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); + testClustertestSimpleOptionalArgumentRequestCommandParams.put("arg1",testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testSimpleOptionalArgumentRequest((DefaultClusterCallback) callback + , (Optional) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestSimpleOptionalArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testSimpleOptionalArgumentRequest", testClustertestSimpleOptionalArgumentRequestInteractionInfo); + Map testClustertestSpecificCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestSpecificInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testSpecific((ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback + + ); + }, + () -> new DelegatedTestSpecificResponseCallback(), + testClustertestSpecificCommandParams + ); + testClusterClusterInteractionInfoMap.put("testSpecific", testClustertestSpecificInteractionInfo); + Map testClustertestStructArgumentRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestStructArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ChipStructs.TestClusterClusterSimpleStruct) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestStructArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testStructArgumentRequest", testClustertestStructArgumentRequestInteractionInfo); + Map testClustertestUnknownCommandCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestUnknownCommandInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testUnknownCommand((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestUnknownCommandCommandParams + ); + testClusterClusterInteractionInfoMap.put("testUnknownCommand", testClustertestUnknownCommandInteractionInfo); + Map testClustertimedInvokeRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertimedInvokeRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .timedInvokeRequest((DefaultClusterCallback) callback + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertimedInvokeRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("timedInvokeRequest", testClustertimedInvokeRequestInteractionInfo); + commandMap.put("testCluster", testClusterClusterInteractionInfoMap); + Map thermostatClusterInteractionInfoMap = new LinkedHashMap<>(); + Map thermostatclearWeeklyScheduleCommandParams = new LinkedHashMap(); + InteractionInfo thermostatclearWeeklyScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .clearWeeklySchedule((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatclearWeeklyScheduleCommandParams + ); + thermostatClusterInteractionInfoMap.put("clearWeeklySchedule", thermostatclearWeeklyScheduleInteractionInfo); + Map thermostatgetRelayStatusLogCommandParams = new LinkedHashMap(); + InteractionInfo thermostatgetRelayStatusLogInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .getRelayStatusLog((ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback + + ); + }, + () -> new DelegatedGetRelayStatusLogResponseCallback(), + thermostatgetRelayStatusLogCommandParams + ); + thermostatClusterInteractionInfoMap.put("getRelayStatusLog", thermostatgetRelayStatusLogInteractionInfo); + Map thermostatgetWeeklyScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = new CommandParameterInfo("daysToReturn", Integer.class); + thermostatgetWeeklyScheduleCommandParams.put("daysToReturn",thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); + + CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = new CommandParameterInfo("modeToReturn", Integer.class); + thermostatgetWeeklyScheduleCommandParams.put("modeToReturn",thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); + + InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .getWeeklySchedule((ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback) callback + , (Integer) + commandArguments.get("daysToReturn") + , (Integer) + commandArguments.get("modeToReturn") + + ); + }, + () -> new DelegatedGetWeeklyScheduleResponseCallback(), + thermostatgetWeeklyScheduleCommandParams + ); + thermostatClusterInteractionInfoMap.put("getWeeklySchedule", thermostatgetWeeklyScheduleInteractionInfo); + Map thermostatsetWeeklyScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put("numberOfTransitionsForSequence",thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = new CommandParameterInfo("dayOfWeekForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put("dayOfWeekForSequence",thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = new CommandParameterInfo("modeForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put("modeForSequence",thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = new CommandParameterInfo("payload", ArrayList.class); + thermostatsetWeeklyScheduleCommandParams.put("payload",thermostatsetWeeklySchedulepayloadCommandParameterInfo); + + InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .setWeeklySchedule((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("numberOfTransitionsForSequence") + , (Integer) + commandArguments.get("dayOfWeekForSequence") + , (Integer) + commandArguments.get("modeForSequence") + , (ArrayList) + commandArguments.get("payload") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatsetWeeklyScheduleCommandParams + ); + thermostatClusterInteractionInfoMap.put("setWeeklySchedule", thermostatsetWeeklyScheduleInteractionInfo); + Map thermostatsetpointRaiseLowerCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = new CommandParameterInfo("mode", Integer.class); + thermostatsetpointRaiseLowerCommandParams.put("mode",thermostatsetpointRaiseLowermodeCommandParameterInfo); + + CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = new CommandParameterInfo("amount", Integer.class); + thermostatsetpointRaiseLowerCommandParams.put("amount",thermostatsetpointRaiseLoweramountCommandParameterInfo); + + InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .setpointRaiseLower((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("mode") + , (Integer) + commandArguments.get("amount") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatsetpointRaiseLowerCommandParams + ); + thermostatClusterInteractionInfoMap.put("setpointRaiseLower", thermostatsetpointRaiseLowerInteractionInfo); + commandMap.put("thermostat", thermostatClusterInteractionInfoMap); + Map thermostatUserInterfaceConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInteractionInfoMap); + Map threadNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map threadNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); + InteractionInfo threadNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + threadNetworkDiagnosticsresetCountsCommandParams + ); + threadNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", threadNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInteractionInfoMap); + Map timeFormatLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("timeFormatLocalization", timeFormatLocalizationClusterInteractionInfoMap); + Map unitLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("unitLocalization", unitLocalizationClusterInteractionInfoMap); + Map userLabelClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("userLabel", userLabelClusterInteractionInfoMap); + Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); + Map wiFiNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map wiFiNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); + InteractionInfo wiFiNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + wiFiNetworkDiagnosticsresetCountsCommandParams + ); + wiFiNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", wiFiNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInteractionInfoMap); + Map windowCoveringClusterInteractionInfoMap = new LinkedHashMap<>(); + Map windowCoveringdownOrCloseCommandParams = new LinkedHashMap(); + InteractionInfo windowCoveringdownOrCloseInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .downOrClose((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringdownOrCloseCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("downOrClose", windowCoveringdownOrCloseInteractionInfo); + Map windowCoveringgoToLiftPercentageCommandParams = new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = new CommandParameterInfo("liftPercentageValue", Integer.class); + windowCoveringgoToLiftPercentageCommandParams.put("liftPercentageValue",windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); + + CommandParameterInfo windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = new CommandParameterInfo("liftPercent100thsValue", Integer.class); + windowCoveringgoToLiftPercentageCommandParams.put("liftPercent100thsValue",windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToLiftPercentage((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("liftPercentageValue") + , (Integer) + commandArguments.get("liftPercent100thsValue") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToLiftPercentageCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("goToLiftPercentage", windowCoveringgoToLiftPercentageInteractionInfo); + Map windowCoveringgoToLiftValueCommandParams = new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = new CommandParameterInfo("liftValue", Integer.class); + windowCoveringgoToLiftValueCommandParams.put("liftValue",windowCoveringgoToLiftValueliftValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToLiftValueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToLiftValue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("liftValue") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToLiftValueCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("goToLiftValue", windowCoveringgoToLiftValueInteractionInfo); + Map windowCoveringgoToTiltPercentageCommandParams = new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = new CommandParameterInfo("tiltPercentageValue", Integer.class); + windowCoveringgoToTiltPercentageCommandParams.put("tiltPercentageValue",windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); + + CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = new CommandParameterInfo("tiltPercent100thsValue", Integer.class); + windowCoveringgoToTiltPercentageCommandParams.put("tiltPercent100thsValue",windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToTiltPercentage((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("tiltPercentageValue") + , (Integer) + commandArguments.get("tiltPercent100thsValue") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToTiltPercentageCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("goToTiltPercentage", windowCoveringgoToTiltPercentageInteractionInfo); + Map windowCoveringgoToTiltValueCommandParams = new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = new CommandParameterInfo("tiltValue", Integer.class); + windowCoveringgoToTiltValueCommandParams.put("tiltValue",windowCoveringgoToTiltValuetiltValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToTiltValueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToTiltValue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("tiltValue") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToTiltValueCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("goToTiltValue", windowCoveringgoToTiltValueInteractionInfo); + Map windowCoveringstopMotionCommandParams = new LinkedHashMap(); + InteractionInfo windowCoveringstopMotionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .stopMotion((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringstopMotionCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("stopMotion", windowCoveringstopMotionInteractionInfo); + Map windowCoveringupOrOpenCommandParams = new LinkedHashMap(); + InteractionInfo windowCoveringupOrOpenInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .upOrOpen((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringupOrOpenCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("upOrOpen", windowCoveringupOrOpenInteractionInfo); + commandMap.put("windowCovering", windowCoveringClusterInteractionInfoMap); + return commandMap; } - public static class DelegatedBasicClusterAttributeListAttributeCallback - implements ChipClusters.BasicCluster.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 DelegatedBinaryInputBasicClusterAttributeListAttributeCallback - implements ChipClusters.BinaryInputBasicCluster.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 DelegatedBindingClusterAttributeListAttributeCallback - implements ChipClusters.BindingCluster.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 DelegatedBooleanStateClusterAttributeListAttributeCallback - implements ChipClusters.BooleanStateCluster.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 DelegatedBridgedActionsClusterActionListAttributeCallback - implements ChipClusters.BridgedActionsCluster.ActionListAttributeCallback, - 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 DelegatedBridgedActionsClusterEndpointListAttributeCallback - implements ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback, - 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 DelegatedBridgedActionsClusterAttributeListAttributeCallback - implements ChipClusters.BridgedActionsCluster.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 DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback - implements ChipClusters.BridgedDeviceBasicCluster.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 DelegatedChangeChannelResponseCallback - implements ChipClusters.ChannelCluster.ChangeChannelResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType) { - Map responseValues = new LinkedHashMap<>(); - // channelMatch: Struct ChannelInfo - // Conversion from this type to Java is not properly implemented yet - CommandResponseInfo errorTypeResponseValue = new CommandResponseInfo("errorType", "Integer"); - responseValues.put(errorTypeResponseValue, errorType); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedChannelClusterChannelListAttributeCallback - implements ChipClusters.ChannelCluster.ChannelListAttributeCallback, - 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 DelegatedChannelClusterAttributeListAttributeCallback - implements ChipClusters.ChannelCluster.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 DelegatedColorControlClusterAttributeListAttributeCallback - implements ChipClusters.ColorControlCluster.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 DelegatedLaunchResponseCallback - implements ChipClusters.ContentLauncherCluster.LaunchResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback - implements ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback, - 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 DelegatedContentLauncherClusterAttributeListAttributeCallback - implements ChipClusters.ContentLauncherCluster.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 DelegatedDescriptorClusterDeviceListAttributeCallback - implements ChipClusters.DescriptorCluster.DeviceListAttributeCallback, - 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 DelegatedDescriptorClusterServerListAttributeCallback - implements ChipClusters.DescriptorCluster.ServerListAttributeCallback, - 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 DelegatedDescriptorClusterClientListAttributeCallback - implements ChipClusters.DescriptorCluster.ClientListAttributeCallback, - 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 DelegatedDescriptorClusterPartsListAttributeCallback - implements ChipClusters.DescriptorCluster.PartsListAttributeCallback, - 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 DelegatedDescriptorClusterAttributeListAttributeCallback - implements ChipClusters.DescriptorCluster.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 DelegatedRetrieveLogsResponseCallback - implements ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo contentResponseValue = new CommandResponseInfo("content", "byte[]"); - responseValues.put(contentResponseValue, content); - CommandResponseInfo timeStampResponseValue = new CommandResponseInfo("timeStamp", "Long"); - responseValues.put(timeStampResponseValue, timeStamp); - CommandResponseInfo timeSinceBootResponseValue = - new CommandResponseInfo("timeSinceBoot", "Long"); - responseValues.put(timeSinceBootResponseValue, timeSinceBoot); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedDiagnosticLogsClusterAttributeListAttributeCallback - implements ChipClusters.DiagnosticLogsCluster.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 DelegatedGetCredentialStatusResponseCallback - implements ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Boolean credentialExists, - @Nullable Integer userIndex, - @Nullable Integer nextCredentialIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo credentialExistsResponseValue = - new CommandResponseInfo("credentialExists", "Boolean"); - responseValues.put(credentialExistsResponseValue, credentialExists); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo nextCredentialIndexResponseValue = - new CommandResponseInfo("nextCredentialIndex", "Integer"); - responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetUserResponseCallback - implements ChipClusters.DoorLockCluster.GetUserResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer userIndex, - @Nullable String userName, - @Nullable Long userUniqueId, - @Nullable Integer userStatus, - @Nullable Integer userType, - @Nullable Integer credentialRule, - @Nullable ArrayList credentials, - @Nullable Integer creatorFabricIndex, - @Nullable Integer lastModifiedFabricIndex, - @Nullable Integer nextUserIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo userNameResponseValue = new CommandResponseInfo("userName", "String"); - responseValues.put(userNameResponseValue, userName); - CommandResponseInfo userUniqueIdResponseValue = - new CommandResponseInfo("userUniqueId", "Long"); - responseValues.put(userUniqueIdResponseValue, userUniqueId); - CommandResponseInfo userStatusResponseValue = - new CommandResponseInfo("userStatus", "Integer"); - responseValues.put(userStatusResponseValue, userStatus); - CommandResponseInfo userTypeResponseValue = new CommandResponseInfo("userType", "Integer"); - responseValues.put(userTypeResponseValue, userType); - CommandResponseInfo credentialRuleResponseValue = - new CommandResponseInfo("credentialRule", "Integer"); - responseValues.put(credentialRuleResponseValue, credentialRule); - // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - CommandResponseInfo creatorFabricIndexResponseValue = - new CommandResponseInfo("creatorFabricIndex", "Integer"); - responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); - CommandResponseInfo lastModifiedFabricIndexResponseValue = - new CommandResponseInfo("lastModifiedFabricIndex", "Integer"); - responseValues.put(lastModifiedFabricIndexResponseValue, lastModifiedFabricIndex); - CommandResponseInfo nextUserIndexResponseValue = - new CommandResponseInfo("nextUserIndex", "Integer"); - responseValues.put(nextUserIndexResponseValue, nextUserIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetWeekDayScheduleResponseCallback - implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer weekDayIndex, - Integer userIndex, - Integer status, - Optional daysMask, - Optional startHour, - Optional startMinute, - Optional endHour, - Optional endMinute) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo weekDayIndexResponseValue = - new CommandResponseInfo("weekDayIndex", "Integer"); - responseValues.put(weekDayIndexResponseValue, weekDayIndex); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo daysMaskResponseValue = - new CommandResponseInfo("daysMask", "Optional"); - responseValues.put(daysMaskResponseValue, daysMask); - CommandResponseInfo startHourResponseValue = - new CommandResponseInfo("startHour", "Optional"); - responseValues.put(startHourResponseValue, startHour); - CommandResponseInfo startMinuteResponseValue = - new CommandResponseInfo("startMinute", "Optional"); - responseValues.put(startMinuteResponseValue, startMinute); - CommandResponseInfo endHourResponseValue = - new CommandResponseInfo("endHour", "Optional"); - responseValues.put(endHourResponseValue, endHour); - CommandResponseInfo endMinuteResponseValue = - new CommandResponseInfo("endMinute", "Optional"); - responseValues.put(endMinuteResponseValue, endMinute); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetYearDayScheduleResponseCallback - implements ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer yearDayIndex, - Integer userIndex, - Integer status, - Optional localStartTime, - Optional localEndTime) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo yearDayIndexResponseValue = - new CommandResponseInfo("yearDayIndex", "Integer"); - responseValues.put(yearDayIndexResponseValue, yearDayIndex); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo localStartTimeResponseValue = - new CommandResponseInfo("localStartTime", "Optional"); - responseValues.put(localStartTimeResponseValue, localStartTime); - CommandResponseInfo localEndTimeResponseValue = - new CommandResponseInfo("localEndTime", "Optional"); - responseValues.put(localEndTimeResponseValue, localEndTime); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSetCredentialResponseCallback - implements ChipClusters.DoorLockCluster.SetCredentialResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo nextCredentialIndexResponseValue = - new CommandResponseInfo("nextCredentialIndex", "Integer"); - responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedDoorLockClusterAttributeListAttributeCallback - implements ChipClusters.DoorLockCluster.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 DelegatedElectricalMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.ElectricalMeasurementCluster.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 DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback - implements ChipClusters.EthernetNetworkDiagnosticsCluster.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 DelegatedFixedLabelClusterLabelListAttributeCallback - implements ChipClusters.FixedLabelCluster.LabelListAttributeCallback, - 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 DelegatedFixedLabelClusterAttributeListAttributeCallback - implements ChipClusters.FixedLabelCluster.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 DelegatedFlowMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.FlowMeasurementCluster.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 DelegatedArmFailSafeResponseCallback - implements ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedCommissioningCompleteResponseCallback - implements ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSetRegulatoryConfigResponseCallback - implements ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static - class DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback - implements ChipClusters.GeneralCommissioningCluster - .BasicCommissioningInfoListAttributeCallback, - 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 DelegatedGeneralCommissioningClusterAttributeListAttributeCallback - implements ChipClusters.GeneralCommissioningCluster.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 DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback - implements ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback, - 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 DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback - implements ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback, - 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 DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback - implements ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback, - 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 DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback - implements ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback, - 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 DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback - implements ChipClusters.GeneralDiagnosticsCluster.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 DelegatedKeySetReadAllIndicesResponseCallback - implements ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ArrayList groupKeySetIDs) { - Map responseValues = new LinkedHashMap<>(); - // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedKeySetReadResponseCallback - implements ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { - Map responseValues = new LinkedHashMap<>(); - // groupKeySet: Struct GroupKeySet - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback - implements ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback, - 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 DelegatedGroupKeyManagementClusterGroupTableAttributeCallback - implements ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback, - 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 DelegatedGroupKeyManagementClusterAttributeListAttributeCallback - implements ChipClusters.GroupKeyManagementCluster.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 DelegatedAddGroupResponseCallback - implements ChipClusters.GroupsCluster.AddGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetGroupMembershipResponseCallback - implements ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer capacity, ArrayList groupList) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); - responseValues.put(capacityResponseValue, capacity); - // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveGroupResponseCallback - implements ChipClusters.GroupsCluster.RemoveGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedViewGroupResponseCallback - implements ChipClusters.GroupsCluster.ViewGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, String groupName) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo groupNameResponseValue = new CommandResponseInfo("groupName", "String"); - responseValues.put(groupNameResponseValue, groupName); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGroupsClusterAttributeListAttributeCallback - implements ChipClusters.GroupsCluster.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 DelegatedIdentifyQueryResponseCallback - implements ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer timeout) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo timeoutResponseValue = new CommandResponseInfo("timeout", "Integer"); - responseValues.put(timeoutResponseValue, timeout); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedIdentifyClusterAttributeListAttributeCallback - implements ChipClusters.IdentifyCluster.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 DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.IlluminanceMeasurementCluster.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 DelegatedSendKeyResponseCallback - implements ChipClusters.KeypadInputCluster.SendKeyResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedKeypadInputClusterAttributeListAttributeCallback - implements ChipClusters.KeypadInputCluster.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 DelegatedLevelControlClusterAttributeListAttributeCallback - implements ChipClusters.LevelControlCluster.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 DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback - implements ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback, - 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 DelegatedLowPowerClusterAttributeListAttributeCallback - implements ChipClusters.LowPowerCluster.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 DelegatedMediaInputClusterMediaInputListAttributeCallback - implements ChipClusters.MediaInputCluster.MediaInputListAttributeCallback, - 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 DelegatedMediaInputClusterAttributeListAttributeCallback - implements ChipClusters.MediaInputCluster.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 DelegatedPlaybackResponseCallback - implements ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedMediaPlaybackClusterAttributeListAttributeCallback - implements ChipClusters.MediaPlaybackCluster.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 DelegatedModeSelectClusterSupportedModesAttributeCallback - implements ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback, - 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 DelegatedModeSelectClusterAttributeListAttributeCallback - implements ChipClusters.ModeSelectCluster.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 DelegatedConnectNetworkResponseCallback - implements ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText, Long ErrorValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = - new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - CommandResponseInfo ErrorValueResponseValue = new CommandResponseInfo("ErrorValue", "Long"); - responseValues.put(ErrorValueResponseValue, ErrorValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNetworkConfigResponseCallback - implements ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = - new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedScanNetworksResponseCallback - implements ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer NetworkingStatus, - String DebugText, - Optional> - WiFiScanResults, - Optional> - ThreadScanResults) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = - new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - // WiFiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - // ThreadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNetworkCommissioningClusterNetworksAttributeCallback - implements ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback, - 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 DelegatedApplyUpdateResponseCallback - implements ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer action, Long delayedActionTime) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo actionResponseValue = new CommandResponseInfo("action", "Integer"); - responseValues.put(actionResponseValue, action); - CommandResponseInfo delayedActionTimeResponseValue = - new CommandResponseInfo("delayedActionTime", "Long"); - responseValues.put(delayedActionTimeResponseValue, delayedActionTime); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedQueryImageResponseCallback - implements ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer status, - Optional delayedActionTime, - Optional imageURI, - Optional softwareVersion, - Optional softwareVersionString, - Optional updateToken, - Optional userConsentNeeded, - Optional metadataForRequestor) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo delayedActionTimeResponseValue = - new CommandResponseInfo("delayedActionTime", "Optional"); - responseValues.put(delayedActionTimeResponseValue, delayedActionTime); - CommandResponseInfo imageURIResponseValue = - new CommandResponseInfo("imageURI", "Optional"); - responseValues.put(imageURIResponseValue, imageURI); - CommandResponseInfo softwareVersionResponseValue = - new CommandResponseInfo("softwareVersion", "Optional"); - responseValues.put(softwareVersionResponseValue, softwareVersion); - CommandResponseInfo softwareVersionStringResponseValue = - new CommandResponseInfo("softwareVersionString", "Optional"); - responseValues.put(softwareVersionStringResponseValue, softwareVersionString); - CommandResponseInfo updateTokenResponseValue = - new CommandResponseInfo("updateToken", "Optional"); - responseValues.put(updateTokenResponseValue, updateToken); - CommandResponseInfo userConsentNeededResponseValue = - new CommandResponseInfo("userConsentNeeded", "Optional"); - responseValues.put(userConsentNeededResponseValue, userConsentNeeded); - CommandResponseInfo metadataForRequestorResponseValue = - new CommandResponseInfo("metadataForRequestor", "Optional"); - responseValues.put(metadataForRequestorResponseValue, metadataForRequestor); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback - implements ChipClusters.OtaSoftwareUpdateProviderCluster.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 DelegatedOtaSoftwareUpdateRequestorClusterDefaultOtaProvidersAttributeCallback - implements ChipClusters.OtaSoftwareUpdateRequestorCluster - .DefaultOtaProvidersAttributeCallback, - 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 DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback - implements ChipClusters.OtaSoftwareUpdateRequestorCluster.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 DelegatedOccupancySensingClusterAttributeListAttributeCallback - implements ChipClusters.OccupancySensingCluster.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 DelegatedOnOffClusterAttributeListAttributeCallback - implements ChipClusters.OnOffCluster.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 DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback - implements ChipClusters.OnOffSwitchConfigurationCluster.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 DelegatedAttestationResponseCallback - implements ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] AttestationElements, byte[] Signature) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo AttestationElementsResponseValue = - new CommandResponseInfo("AttestationElements", "byte[]"); - responseValues.put(AttestationElementsResponseValue, AttestationElements); - CommandResponseInfo SignatureResponseValue = new CommandResponseInfo("Signature", "byte[]"); - responseValues.put(SignatureResponseValue, Signature); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedCertificateChainResponseCallback - implements ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] Certificate) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo CertificateResponseValue = - new CommandResponseInfo("Certificate", "byte[]"); - responseValues.put(CertificateResponseValue, Certificate); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNOCResponseCallback - implements ChipClusters.OperationalCredentialsCluster.NOCResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer StatusCode, Integer FabricIndex, String DebugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo StatusCodeResponseValue = - new CommandResponseInfo("StatusCode", "Integer"); - responseValues.put(StatusCodeResponseValue, StatusCode); - CommandResponseInfo FabricIndexResponseValue = - new CommandResponseInfo("FabricIndex", "Integer"); - responseValues.put(FabricIndexResponseValue, FabricIndex); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedOpCSRResponseCallback - implements ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] NOCSRElements, byte[] AttestationSignature) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NOCSRElementsResponseValue = - new CommandResponseInfo("NOCSRElements", "byte[]"); - responseValues.put(NOCSRElementsResponseValue, NOCSRElements); - CommandResponseInfo AttestationSignatureResponseValue = - new CommandResponseInfo("AttestationSignature", "byte[]"); - responseValues.put(AttestationSignatureResponseValue, AttestationSignature); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedOperationalCredentialsClusterNOCsAttributeCallback - implements ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback, - 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 DelegatedOperationalCredentialsClusterFabricsListAttributeCallback - implements ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback, - 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 DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback - implements ChipClusters.OperationalCredentialsCluster - .TrustedRootCertificatesAttributeCallback, - 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 DelegatedOperationalCredentialsClusterAttributeListAttributeCallback - implements ChipClusters.OperationalCredentialsCluster.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 DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback - implements ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback, - 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 DelegatedPowerSourceClusterAttributeListAttributeCallback - implements ChipClusters.PowerSourceCluster.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 DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback - implements ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback, - 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 DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback - implements ChipClusters.PowerSourceConfigurationCluster.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 DelegatedPressureMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.PressureMeasurementCluster.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 DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback - implements ChipClusters.PumpConfigurationAndControlCluster.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 DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.RelativeHumidityMeasurementCluster.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 DelegatedAddSceneResponseCallback - implements ChipClusters.ScenesCluster.AddSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetSceneMembershipResponseCallback - implements ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer status, - Integer capacity, - Integer groupId, - Integer sceneCount, - ArrayList sceneList) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); - responseValues.put(capacityResponseValue, capacity); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneCountResponseValue = - new CommandResponseInfo("sceneCount", "Integer"); - responseValues.put(sceneCountResponseValue, sceneCount); - // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveAllScenesResponseCallback - implements ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveSceneResponseCallback - implements ChipClusters.ScenesCluster.RemoveSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedStoreSceneResponseCallback - implements ChipClusters.ScenesCluster.StoreSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedViewSceneResponseCallback - implements ChipClusters.ScenesCluster.ViewSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer status, - Integer groupId, - Integer sceneId, - Integer transitionTime, - String sceneName, - ArrayList extensionFieldSets) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - CommandResponseInfo transitionTimeResponseValue = - new CommandResponseInfo("transitionTime", "Integer"); - responseValues.put(transitionTimeResponseValue, transitionTime); - CommandResponseInfo sceneNameResponseValue = new CommandResponseInfo("sceneName", "String"); - responseValues.put(sceneNameResponseValue, sceneName); - // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedScenesClusterAttributeListAttributeCallback - implements ChipClusters.ScenesCluster.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 DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback - implements ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback, - 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 DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback - implements ChipClusters.SoftwareDiagnosticsCluster.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 DelegatedSwitchClusterAttributeListAttributeCallback - implements ChipClusters.SwitchCluster.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 DelegatedNavigateTargetResponseCallback - implements ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback - implements ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback, - 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 DelegatedTargetNavigatorClusterAttributeListAttributeCallback - implements ChipClusters.TargetNavigatorCluster.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 DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.TemperatureMeasurementCluster.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 DelegatedBooleanResponseCallback - implements ChipClusters.TestClusterCluster.BooleanResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Boolean value) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Boolean"); - responseValues.put(valueResponseValue, value); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSimpleStructResponseCallback - implements ChipClusters.TestClusterCluster.SimpleStructResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1) { - Map responseValues = new LinkedHashMap<>(); - // arg1: Struct SimpleStruct - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestAddArgumentsResponseCallback - implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer returnValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo returnValueResponseValue = - new CommandResponseInfo("returnValue", "Integer"); - responseValues.put(returnValueResponseValue, returnValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestEmitTestEventResponseCallback - implements ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Long value) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Long"); - responseValues.put(valueResponseValue, value); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestEnumsResponseCallback - implements ChipClusters.TestClusterCluster.TestEnumsResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer arg1, Integer arg2) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo arg1ResponseValue = new CommandResponseInfo("arg1", "Integer"); - responseValues.put(arg1ResponseValue, arg1); - CommandResponseInfo arg2ResponseValue = new CommandResponseInfo("arg2", "Integer"); - responseValues.put(arg2ResponseValue, arg2); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestListInt8UReverseResponseCallback - implements ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ArrayList arg1) { - Map responseValues = new LinkedHashMap<>(); - // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestNullableOptionalResponseCallback - implements ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Boolean wasPresent, - Optional wasNull, - Optional value, - @Nullable Optional originalValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo wasPresentResponseValue = - new CommandResponseInfo("wasPresent", "Boolean"); - responseValues.put(wasPresentResponseValue, wasPresent); - CommandResponseInfo wasNullResponseValue = - new CommandResponseInfo("wasNull", "Optional"); - responseValues.put(wasNullResponseValue, wasNull); - CommandResponseInfo valueResponseValue = - new CommandResponseInfo("value", "Optional"); - responseValues.put(valueResponseValue, value); - CommandResponseInfo originalValueResponseValue = - new CommandResponseInfo("originalValue", "Optional"); - responseValues.put(originalValueResponseValue, originalValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestSpecificResponseCallback - implements ChipClusters.TestClusterCluster.TestSpecificResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer returnValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo returnValueResponseValue = - new CommandResponseInfo("returnValue", "Integer"); - responseValues.put(returnValueResponseValue, returnValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestClusterClusterListInt8uAttributeCallback - implements ChipClusters.TestClusterCluster.ListInt8uAttributeCallback, - 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 DelegatedTestClusterClusterListOctetStringAttributeCallback - implements ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback, - 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 DelegatedTestClusterClusterListStructOctetStringAttributeCallback - implements ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback, - 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 DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback - implements ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback, - 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 DelegatedTestClusterClusterListLongOctetStringAttributeCallback - implements ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback, - 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 DelegatedTestClusterClusterAttributeListAttributeCallback - implements ChipClusters.TestClusterCluster.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 DelegatedGetRelayStatusLogResponseCallback - implements ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer timeOfDay, - Integer relayStatus, - Integer localTemperature, - Integer humidityInPercentage, - Integer setpoint, - Integer unreadEntries) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo timeOfDayResponseValue = new CommandResponseInfo("timeOfDay", "Integer"); - responseValues.put(timeOfDayResponseValue, timeOfDay); - CommandResponseInfo relayStatusResponseValue = - new CommandResponseInfo("relayStatus", "Integer"); - responseValues.put(relayStatusResponseValue, relayStatus); - CommandResponseInfo localTemperatureResponseValue = - new CommandResponseInfo("localTemperature", "Integer"); - responseValues.put(localTemperatureResponseValue, localTemperature); - CommandResponseInfo humidityInPercentageResponseValue = - new CommandResponseInfo("humidityInPercentage", "Integer"); - responseValues.put(humidityInPercentageResponseValue, humidityInPercentage); - CommandResponseInfo setpointResponseValue = new CommandResponseInfo("setpoint", "Integer"); - responseValues.put(setpointResponseValue, setpoint); - CommandResponseInfo unreadEntriesResponseValue = - new CommandResponseInfo("unreadEntries", "Integer"); - responseValues.put(unreadEntriesResponseValue, unreadEntries); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetWeeklyScheduleResponseCallback - implements ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer numberOfTransitionsForSequence, - Integer dayOfWeekForSequence, - Integer modeForSequence, - ArrayList payload) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo numberOfTransitionsForSequenceResponseValue = - new CommandResponseInfo("numberOfTransitionsForSequence", "Integer"); - responseValues.put( - numberOfTransitionsForSequenceResponseValue, numberOfTransitionsForSequence); - CommandResponseInfo dayOfWeekForSequenceResponseValue = - new CommandResponseInfo("dayOfWeekForSequence", "Integer"); - responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); - CommandResponseInfo modeForSequenceResponseValue = - new CommandResponseInfo("modeForSequence", "Integer"); - responseValues.put(modeForSequenceResponseValue, modeForSequence); - // payload: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedThermostatClusterAttributeListAttributeCallback - implements ChipClusters.ThermostatCluster.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 DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback - implements ChipClusters.ThermostatUserInterfaceConfigurationCluster - .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 DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback, - 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 DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback, - 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 DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback, - 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 DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster - .OperationalDatasetComponentsAttributeCallback, - 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 DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster - .ActiveNetworkFaultsListAttributeCallback, - 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 DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster.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 DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback - implements ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback, - 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 DelegatedUserLabelClusterLabelListAttributeCallback - implements ChipClusters.UserLabelCluster.LabelListAttributeCallback, - 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 DelegatedWakeOnLanClusterAttributeListAttributeCallback - implements ChipClusters.WakeOnLanCluster.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 DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback - implements ChipClusters.WiFiNetworkDiagnosticsCluster.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 DelegatedWindowCoveringClusterAttributeListAttributeCallback - implements ChipClusters.WindowCoveringCluster.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 Map getClusterMap() { - Map clusterMap = initializeClusterMap(); - Map> commandMap = getCommandMap(); - combineCommand(clusterMap, commandMap); - Map> readAttributeMap = - new ClusterReadMapping().getReadAttributeMap(); - combineCommand(clusterMap, readAttributeMap); - Map> writeAttributeMap = - new ClusterWriteMapping().getWriteAttributeMap(); - combineCommand(clusterMap, writeAttributeMap); - return clusterMap; - } - - public Map initializeClusterMap() { - Map clusterMap = new HashMap<>(); - ClusterInfo accessControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AccessControlCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("accessControl", accessControlClusterInfo); - ClusterInfo accountLoginClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("accountLogin", accountLoginClusterInfo); - ClusterInfo administratorCommissioningClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); - ClusterInfo applicationBasicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("applicationBasic", applicationBasicClusterInfo); - ClusterInfo applicationLauncherClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); - ClusterInfo audioOutputClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("audioOutput", audioOutputClusterInfo); - ClusterInfo barrierControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("barrierControl", barrierControlClusterInfo); - ClusterInfo basicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("basic", basicClusterInfo); - ClusterInfo binaryInputBasicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); - ClusterInfo bindingClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("binding", bindingClusterInfo); - ClusterInfo booleanStateClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("booleanState", booleanStateClusterInfo); - ClusterInfo bridgedActionsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("bridgedActions", bridgedActionsClusterInfo); - ClusterInfo bridgedDeviceBasicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); - ClusterInfo channelClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ChannelCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("channel", channelClusterInfo); - ClusterInfo colorControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("colorControl", colorControlClusterInfo); - ClusterInfo contentLauncherClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("contentLauncher", contentLauncherClusterInfo); - ClusterInfo descriptorClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("descriptor", descriptorClusterInfo); - ClusterInfo diagnosticLogsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); - ClusterInfo doorLockClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("doorLock", doorLockClusterInfo); - ClusterInfo electricalMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); - ClusterInfo ethernetNetworkDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); - ClusterInfo fixedLabelClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("fixedLabel", fixedLabelClusterInfo); - ClusterInfo flowMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); - ClusterInfo generalCommissioningClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); - ClusterInfo generalDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); - ClusterInfo groupKeyManagementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); - ClusterInfo groupsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("groups", groupsClusterInfo); - ClusterInfo identifyClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("identify", identifyClusterInfo); - ClusterInfo illuminanceMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); - ClusterInfo keypadInputClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("keypadInput", keypadInputClusterInfo); - ClusterInfo levelControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("levelControl", levelControlClusterInfo); - ClusterInfo localizationConfigurationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LocalizationConfigurationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("localizationConfiguration", localizationConfigurationClusterInfo); - ClusterInfo lowPowerClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("lowPower", lowPowerClusterInfo); - ClusterInfo mediaInputClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("mediaInput", mediaInputClusterInfo); - ClusterInfo mediaPlaybackClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); - ClusterInfo modeSelectClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("modeSelect", modeSelectClusterInfo); - ClusterInfo networkCommissioningClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); - ClusterInfo otaSoftwareUpdateProviderClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); - ClusterInfo otaSoftwareUpdateRequestorClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); - ClusterInfo occupancySensingClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("occupancySensing", occupancySensingClusterInfo); - ClusterInfo onOffClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("onOff", onOffClusterInfo); - ClusterInfo onOffSwitchConfigurationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); - ClusterInfo operationalCredentialsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); - ClusterInfo powerSourceClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("powerSource", powerSourceClusterInfo); - ClusterInfo powerSourceConfigurationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PowerSourceConfigurationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInfo); - ClusterInfo pressureMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); - ClusterInfo pumpConfigurationAndControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); - ClusterInfo relativeHumidityMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); - ClusterInfo scenesClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("scenes", scenesClusterInfo); - ClusterInfo softwareDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); - ClusterInfo switchClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("switch", switchClusterInfo); - ClusterInfo targetNavigatorClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("targetNavigator", targetNavigatorClusterInfo); - ClusterInfo temperatureMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); - ClusterInfo testClusterClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("testCluster", testClusterClusterInfo); - ClusterInfo thermostatClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("thermostat", thermostatClusterInfo); - ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put( - "thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); - ClusterInfo threadNetworkDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); - ClusterInfo timeFormatLocalizationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TimeFormatLocalizationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("timeFormatLocalization", timeFormatLocalizationClusterInfo); - ClusterInfo unitLocalizationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.UnitLocalizationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("unitLocalization", unitLocalizationClusterInfo); - ClusterInfo userLabelClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.UserLabelCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("userLabel", userLabelClusterInfo); - ClusterInfo wakeOnLanClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); - ClusterInfo wiFiNetworkDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); - ClusterInfo windowCoveringClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("windowCovering", windowCoveringClusterInfo); - return clusterMap; - } - - public void combineCommand( - Map destination, Map> source) { - destination.get("accessControl").combineCommands(source.get("accessControl")); - destination.get("accountLogin").combineCommands(source.get("accountLogin")); - destination - .get("administratorCommissioning") - .combineCommands(source.get("administratorCommissioning")); - destination.get("applicationBasic").combineCommands(source.get("applicationBasic")); - destination.get("applicationLauncher").combineCommands(source.get("applicationLauncher")); - destination.get("audioOutput").combineCommands(source.get("audioOutput")); - destination.get("barrierControl").combineCommands(source.get("barrierControl")); - destination.get("basic").combineCommands(source.get("basic")); - destination.get("binaryInputBasic").combineCommands(source.get("binaryInputBasic")); - destination.get("binding").combineCommands(source.get("binding")); - destination.get("booleanState").combineCommands(source.get("booleanState")); - destination.get("bridgedActions").combineCommands(source.get("bridgedActions")); - destination.get("bridgedDeviceBasic").combineCommands(source.get("bridgedDeviceBasic")); - destination.get("channel").combineCommands(source.get("channel")); - destination.get("colorControl").combineCommands(source.get("colorControl")); - destination.get("contentLauncher").combineCommands(source.get("contentLauncher")); - destination.get("descriptor").combineCommands(source.get("descriptor")); - destination.get("diagnosticLogs").combineCommands(source.get("diagnosticLogs")); - destination.get("doorLock").combineCommands(source.get("doorLock")); - destination.get("electricalMeasurement").combineCommands(source.get("electricalMeasurement")); - destination - .get("ethernetNetworkDiagnostics") - .combineCommands(source.get("ethernetNetworkDiagnostics")); - destination.get("fixedLabel").combineCommands(source.get("fixedLabel")); - destination.get("flowMeasurement").combineCommands(source.get("flowMeasurement")); - destination.get("generalCommissioning").combineCommands(source.get("generalCommissioning")); - destination.get("generalDiagnostics").combineCommands(source.get("generalDiagnostics")); - destination.get("groupKeyManagement").combineCommands(source.get("groupKeyManagement")); - destination.get("groups").combineCommands(source.get("groups")); - destination.get("identify").combineCommands(source.get("identify")); - destination.get("illuminanceMeasurement").combineCommands(source.get("illuminanceMeasurement")); - destination.get("keypadInput").combineCommands(source.get("keypadInput")); - destination.get("levelControl").combineCommands(source.get("levelControl")); - destination - .get("localizationConfiguration") - .combineCommands(source.get("localizationConfiguration")); - destination.get("lowPower").combineCommands(source.get("lowPower")); - destination.get("mediaInput").combineCommands(source.get("mediaInput")); - destination.get("mediaPlayback").combineCommands(source.get("mediaPlayback")); - destination.get("modeSelect").combineCommands(source.get("modeSelect")); - destination.get("networkCommissioning").combineCommands(source.get("networkCommissioning")); - destination - .get("otaSoftwareUpdateProvider") - .combineCommands(source.get("otaSoftwareUpdateProvider")); - destination - .get("otaSoftwareUpdateRequestor") - .combineCommands(source.get("otaSoftwareUpdateRequestor")); - destination.get("occupancySensing").combineCommands(source.get("occupancySensing")); - destination.get("onOff").combineCommands(source.get("onOff")); - destination - .get("onOffSwitchConfiguration") - .combineCommands(source.get("onOffSwitchConfiguration")); - destination.get("operationalCredentials").combineCommands(source.get("operationalCredentials")); - destination.get("powerSource").combineCommands(source.get("powerSource")); - destination - .get("powerSourceConfiguration") - .combineCommands(source.get("powerSourceConfiguration")); - destination.get("pressureMeasurement").combineCommands(source.get("pressureMeasurement")); - destination - .get("pumpConfigurationAndControl") - .combineCommands(source.get("pumpConfigurationAndControl")); - destination - .get("relativeHumidityMeasurement") - .combineCommands(source.get("relativeHumidityMeasurement")); - destination.get("scenes").combineCommands(source.get("scenes")); - destination.get("softwareDiagnostics").combineCommands(source.get("softwareDiagnostics")); - destination.get("switch").combineCommands(source.get("switch")); - destination.get("targetNavigator").combineCommands(source.get("targetNavigator")); - destination.get("temperatureMeasurement").combineCommands(source.get("temperatureMeasurement")); - destination.get("testCluster").combineCommands(source.get("testCluster")); - destination.get("thermostat").combineCommands(source.get("thermostat")); - destination - .get("thermostatUserInterfaceConfiguration") - .combineCommands(source.get("thermostatUserInterfaceConfiguration")); - destination - .get("threadNetworkDiagnostics") - .combineCommands(source.get("threadNetworkDiagnostics")); - destination.get("timeFormatLocalization").combineCommands(source.get("timeFormatLocalization")); - destination.get("unitLocalization").combineCommands(source.get("unitLocalization")); - destination.get("userLabel").combineCommands(source.get("userLabel")); - destination.get("wakeOnLan").combineCommands(source.get("wakeOnLan")); - destination.get("wiFiNetworkDiagnostics").combineCommands(source.get("wiFiNetworkDiagnostics")); - destination.get("windowCovering").combineCommands(source.get("windowCovering")); - } - - @SuppressWarnings("unchecked") - public Map> getCommandMap() { - Map> commandMap = new HashMap<>(); - Map accessControlClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("accessControl", accessControlClusterInteractionInfoMap); - Map accountLoginClusterInteractionInfoMap = new LinkedHashMap<>(); - Map accountLogingetSetupPINRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = - new CommandParameterInfo("tempAccountIdentifier", String.class); - accountLogingetSetupPINRequestCommandParams.put( - "tempAccountIdentifier", - accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); - - InteractionInfo accountLogingetSetupPINRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .getSetupPINRequest( - (ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback) callback, - (String) commandArguments.get("tempAccountIdentifier"), - 10000); - }, - () -> new DelegatedGetSetupPINResponseCallback(), - accountLogingetSetupPINRequestCommandParams); - accountLoginClusterInteractionInfoMap.put( - "getSetupPINRequest", accountLogingetSetupPINRequestInteractionInfo); - Map accountLoginloginRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = - new CommandParameterInfo("tempAccountIdentifier", String.class); - accountLoginloginRequestCommandParams.put( - "tempAccountIdentifier", accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); - - CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = - new CommandParameterInfo("setupPIN", String.class); - accountLoginloginRequestCommandParams.put( - "setupPIN", accountLoginloginRequestsetupPINCommandParameterInfo); - - InteractionInfo accountLoginloginRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .loginRequest( - (DefaultClusterCallback) callback, - (String) commandArguments.get("tempAccountIdentifier"), - (String) commandArguments.get("setupPIN"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - accountLoginloginRequestCommandParams); - accountLoginClusterInteractionInfoMap.put( - "loginRequest", accountLoginloginRequestInteractionInfo); - Map accountLoginlogoutRequestCommandParams = - new LinkedHashMap(); - InteractionInfo accountLoginlogoutRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .logoutRequest((DefaultClusterCallback) callback, 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - accountLoginlogoutRequestCommandParams); - accountLoginClusterInteractionInfoMap.put( - "logoutRequest", accountLoginlogoutRequestInteractionInfo); - commandMap.put("accountLogin", accountLoginClusterInteractionInfoMap); - Map administratorCommissioningClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map - administratorCommissioningopenBasicCommissioningWindowCommandParams = - new LinkedHashMap(); - CommandParameterInfo - administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = - new CommandParameterInfo("commissioningTimeout", Integer.class); - administratorCommissioningopenBasicCommissioningWindowCommandParams.put( - "commissioningTimeout", - administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); - - InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .openBasicCommissioningWindow( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("commissioningTimeout"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningopenBasicCommissioningWindowCommandParams); - administratorCommissioningClusterInteractionInfoMap.put( - "openBasicCommissioningWindow", - administratorCommissioningopenBasicCommissioningWindowInteractionInfo); - Map - administratorCommissioningopenCommissioningWindowCommandParams = - new LinkedHashMap(); - CommandParameterInfo - administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = - new CommandParameterInfo("commissioningTimeout", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "commissioningTimeout", - administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); - - CommandParameterInfo - administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = - new CommandParameterInfo("PAKEVerifier", byte[].class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "PAKEVerifier", - administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); - - CommandParameterInfo - administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = - new CommandParameterInfo("discriminator", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "discriminator", - administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); - - CommandParameterInfo - administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = - new CommandParameterInfo("iterations", Long.class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "iterations", - administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = - new CommandParameterInfo("salt", byte[].class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "salt", administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); - - CommandParameterInfo - administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = - new CommandParameterInfo("passcodeID", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "passcodeID", - administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); - - InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .openCommissioningWindow( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("commissioningTimeout"), - (byte[]) commandArguments.get("PAKEVerifier"), - (Integer) commandArguments.get("discriminator"), - (Long) commandArguments.get("iterations"), - (byte[]) commandArguments.get("salt"), - (Integer) commandArguments.get("passcodeID"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningopenCommissioningWindowCommandParams); - administratorCommissioningClusterInteractionInfoMap.put( - "openCommissioningWindow", - administratorCommissioningopenCommissioningWindowInteractionInfo); - Map administratorCommissioningrevokeCommissioningCommandParams = - new LinkedHashMap(); - InteractionInfo administratorCommissioningrevokeCommissioningInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .revokeCommissioning((DefaultClusterCallback) callback, 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningrevokeCommissioningCommandParams); - administratorCommissioningClusterInteractionInfoMap.put( - "revokeCommissioning", administratorCommissioningrevokeCommissioningInteractionInfo); - commandMap.put( - "administratorCommissioning", administratorCommissioningClusterInteractionInfoMap); - Map applicationBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("applicationBasic", applicationBasicClusterInteractionInfoMap); - Map applicationLauncherClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map applicationLauncherhideAppRequestCommandParams = - new LinkedHashMap(); - InteractionInfo applicationLauncherhideAppRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .hideAppRequest( - (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, - (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application")); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherhideAppRequestCommandParams); - applicationLauncherClusterInteractionInfoMap.put( - "hideAppRequest", applicationLauncherhideAppRequestInteractionInfo); - Map applicationLauncherlaunchAppRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = - new CommandParameterInfo("data", String.class); - applicationLauncherlaunchAppRequestCommandParams.put( - "data", applicationLauncherlaunchAppRequestdataCommandParameterInfo); - - InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .launchAppRequest( - (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, - (String) commandArguments.get("data"), - (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application")); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherlaunchAppRequestCommandParams); - applicationLauncherClusterInteractionInfoMap.put( - "launchAppRequest", applicationLauncherlaunchAppRequestInteractionInfo); - Map applicationLauncherstopAppRequestCommandParams = - new LinkedHashMap(); - InteractionInfo applicationLauncherstopAppRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .stopAppRequest( - (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, - (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application")); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherstopAppRequestCommandParams); - applicationLauncherClusterInteractionInfoMap.put( - "stopAppRequest", applicationLauncherstopAppRequestInteractionInfo); - commandMap.put("applicationLauncher", applicationLauncherClusterInteractionInfoMap); - Map audioOutputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map audioOutputrenameOutputRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = - new CommandParameterInfo("index", Integer.class); - audioOutputrenameOutputRequestCommandParams.put( - "index", audioOutputrenameOutputRequestindexCommandParameterInfo); - - CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = - new CommandParameterInfo("name", String.class); - audioOutputrenameOutputRequestCommandParams.put( - "name", audioOutputrenameOutputRequestnameCommandParameterInfo); - - InteractionInfo audioOutputrenameOutputRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .renameOutputRequest( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("index"), - (String) commandArguments.get("name")); - }, - () -> new DelegatedDefaultClusterCallback(), - audioOutputrenameOutputRequestCommandParams); - audioOutputClusterInteractionInfoMap.put( - "renameOutputRequest", audioOutputrenameOutputRequestInteractionInfo); - Map audioOutputselectOutputRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = - new CommandParameterInfo("index", Integer.class); - audioOutputselectOutputRequestCommandParams.put( - "index", audioOutputselectOutputRequestindexCommandParameterInfo); - - InteractionInfo audioOutputselectOutputRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .selectOutputRequest( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("index")); - }, - () -> new DelegatedDefaultClusterCallback(), - audioOutputselectOutputRequestCommandParams); - audioOutputClusterInteractionInfoMap.put( - "selectOutputRequest", audioOutputselectOutputRequestInteractionInfo); - commandMap.put("audioOutput", audioOutputClusterInteractionInfoMap); - Map barrierControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map barrierControlbarrierControlGoToPercentCommandParams = - new LinkedHashMap(); - CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = - new CommandParameterInfo("percentOpen", Integer.class); - barrierControlbarrierControlGoToPercentCommandParams.put( - "percentOpen", barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); - - InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .barrierControlGoToPercent( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("percentOpen")); - }, - () -> new DelegatedDefaultClusterCallback(), - barrierControlbarrierControlGoToPercentCommandParams); - barrierControlClusterInteractionInfoMap.put( - "barrierControlGoToPercent", barrierControlbarrierControlGoToPercentInteractionInfo); - Map barrierControlbarrierControlStopCommandParams = - new LinkedHashMap(); - InteractionInfo barrierControlbarrierControlStopInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .barrierControlStop((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - barrierControlbarrierControlStopCommandParams); - barrierControlClusterInteractionInfoMap.put( - "barrierControlStop", barrierControlbarrierControlStopInteractionInfo); - commandMap.put("barrierControl", barrierControlClusterInteractionInfoMap); - Map basicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("basic", basicClusterInteractionInfoMap); - Map binaryInputBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("binaryInputBasic", binaryInputBasicClusterInteractionInfoMap); - Map bindingClusterInteractionInfoMap = new LinkedHashMap<>(); - Map bindingbindCommandParams = - new LinkedHashMap(); - CommandParameterInfo bindingbindnodeIdCommandParameterInfo = - new CommandParameterInfo("nodeId", Long.class); - bindingbindCommandParams.put("nodeId", bindingbindnodeIdCommandParameterInfo); - - CommandParameterInfo bindingbindgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - bindingbindCommandParams.put("groupId", bindingbindgroupIdCommandParameterInfo); - - CommandParameterInfo bindingbindendpointIdCommandParameterInfo = - new CommandParameterInfo("endpointId", Integer.class); - bindingbindCommandParams.put("endpointId", bindingbindendpointIdCommandParameterInfo); - - CommandParameterInfo bindingbindclusterIdCommandParameterInfo = - new CommandParameterInfo("clusterId", Long.class); - bindingbindCommandParams.put("clusterId", bindingbindclusterIdCommandParameterInfo); - - InteractionInfo bindingbindInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .bind( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("nodeId"), - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("endpointId"), - (Long) commandArguments.get("clusterId")); - }, - () -> new DelegatedDefaultClusterCallback(), - bindingbindCommandParams); - bindingClusterInteractionInfoMap.put("bind", bindingbindInteractionInfo); - Map bindingunbindCommandParams = - new LinkedHashMap(); - CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = - new CommandParameterInfo("nodeId", Long.class); - bindingunbindCommandParams.put("nodeId", bindingunbindnodeIdCommandParameterInfo); - - CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - bindingunbindCommandParams.put("groupId", bindingunbindgroupIdCommandParameterInfo); - - CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = - new CommandParameterInfo("endpointId", Integer.class); - bindingunbindCommandParams.put("endpointId", bindingunbindendpointIdCommandParameterInfo); - - CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = - new CommandParameterInfo("clusterId", Long.class); - bindingunbindCommandParams.put("clusterId", bindingunbindclusterIdCommandParameterInfo); - - InteractionInfo bindingunbindInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .unbind( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("nodeId"), - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("endpointId"), - (Long) commandArguments.get("clusterId")); - }, - () -> new DelegatedDefaultClusterCallback(), - bindingunbindCommandParams); - bindingClusterInteractionInfoMap.put("unbind", bindingunbindInteractionInfo); - commandMap.put("binding", bindingClusterInteractionInfoMap); - Map booleanStateClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("booleanState", booleanStateClusterInteractionInfoMap); - Map bridgedActionsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map bridgedActionsdisableActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsdisableActionCommandParams.put( - "actionID", bridgedActionsdisableActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsdisableActionCommandParams.put( - "invokeID", bridgedActionsdisableActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsdisableActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .disableAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsdisableActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "disableAction", bridgedActionsdisableActionInteractionInfo); - Map bridgedActionsdisableActionWithDurationCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsdisableActionWithDurationCommandParams.put( - "actionID", bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsdisableActionWithDurationCommandParams.put( - "invokeID", bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = - new CommandParameterInfo("duration", Long.class); - bridgedActionsdisableActionWithDurationCommandParams.put( - "duration", bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .disableActionWithDuration( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID"), - (Long) commandArguments.get("duration")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsdisableActionWithDurationCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "disableActionWithDuration", bridgedActionsdisableActionWithDurationInteractionInfo); - Map bridgedActionsenableActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsenableActionCommandParams.put( - "actionID", bridgedActionsenableActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsenableActionCommandParams.put( - "invokeID", bridgedActionsenableActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsenableActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .enableAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsenableActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "enableAction", bridgedActionsenableActionInteractionInfo); - Map bridgedActionsenableActionWithDurationCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsenableActionWithDurationCommandParams.put( - "actionID", bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsenableActionWithDurationCommandParams.put( - "invokeID", bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = - new CommandParameterInfo("duration", Long.class); - bridgedActionsenableActionWithDurationCommandParams.put( - "duration", bridgedActionsenableActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .enableActionWithDuration( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID"), - (Long) commandArguments.get("duration")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsenableActionWithDurationCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "enableActionWithDuration", bridgedActionsenableActionWithDurationInteractionInfo); - Map bridgedActionsinstantActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsinstantActionCommandParams.put( - "actionID", bridgedActionsinstantActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsinstantActionCommandParams.put( - "invokeID", bridgedActionsinstantActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsinstantActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .instantAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsinstantActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "instantAction", bridgedActionsinstantActionInteractionInfo); - Map bridgedActionsinstantActionWithTransitionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsinstantActionWithTransitionCommandParams.put( - "actionID", bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsinstantActionWithTransitionCommandParams.put( - "invokeID", bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); - - CommandParameterInfo - bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - bridgedActionsinstantActionWithTransitionCommandParams.put( - "transitionTime", - bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); - - InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .instantActionWithTransition( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID"), - (Integer) commandArguments.get("transitionTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsinstantActionWithTransitionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "instantActionWithTransition", bridgedActionsinstantActionWithTransitionInteractionInfo); - Map bridgedActionspauseActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionspauseActionCommandParams.put( - "actionID", bridgedActionspauseActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionspauseActionCommandParams.put( - "invokeID", bridgedActionspauseActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionspauseActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .pauseAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionspauseActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "pauseAction", bridgedActionspauseActionInteractionInfo); - Map bridgedActionspauseActionWithDurationCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionspauseActionWithDurationCommandParams.put( - "actionID", bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionspauseActionWithDurationCommandParams.put( - "invokeID", bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = - new CommandParameterInfo("duration", Long.class); - bridgedActionspauseActionWithDurationCommandParams.put( - "duration", bridgedActionspauseActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .pauseActionWithDuration( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID"), - (Long) commandArguments.get("duration")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionspauseActionWithDurationCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "pauseActionWithDuration", bridgedActionspauseActionWithDurationInteractionInfo); - Map bridgedActionsresumeActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsresumeActionCommandParams.put( - "actionID", bridgedActionsresumeActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsresumeActionCommandParams.put( - "invokeID", bridgedActionsresumeActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsresumeActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .resumeAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsresumeActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "resumeAction", bridgedActionsresumeActionInteractionInfo); - Map bridgedActionsstartActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstartActionCommandParams.put( - "actionID", bridgedActionsstartActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstartActionCommandParams.put( - "invokeID", bridgedActionsstartActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsstartActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .startAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstartActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "startAction", bridgedActionsstartActionInteractionInfo); - Map bridgedActionsstartActionWithDurationCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstartActionWithDurationCommandParams.put( - "actionID", bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstartActionWithDurationCommandParams.put( - "invokeID", bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = - new CommandParameterInfo("duration", Long.class); - bridgedActionsstartActionWithDurationCommandParams.put( - "duration", bridgedActionsstartActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .startActionWithDuration( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID"), - (Long) commandArguments.get("duration")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstartActionWithDurationCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "startActionWithDuration", bridgedActionsstartActionWithDurationInteractionInfo); - Map bridgedActionsstopActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstopActionCommandParams.put( - "actionID", bridgedActionsstopActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstopActionCommandParams.put( - "invokeID", bridgedActionsstopActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsstopActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .stopAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstopActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "stopAction", bridgedActionsstopActionInteractionInfo); - commandMap.put("bridgedActions", bridgedActionsClusterInteractionInfoMap); - Map bridgedDeviceBasicClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInteractionInfoMap); - Map channelClusterInteractionInfoMap = new LinkedHashMap<>(); - Map channelchangeChannelByNumberRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = - new CommandParameterInfo("majorNumber", Integer.class); - channelchangeChannelByNumberRequestCommandParams.put( - "majorNumber", channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); - - CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = - new CommandParameterInfo("minorNumber", Integer.class); - channelchangeChannelByNumberRequestCommandParams.put( - "minorNumber", channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); - - InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .changeChannelByNumberRequest( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("majorNumber"), - (Integer) commandArguments.get("minorNumber")); - }, - () -> new DelegatedDefaultClusterCallback(), - channelchangeChannelByNumberRequestCommandParams); - channelClusterInteractionInfoMap.put( - "changeChannelByNumberRequest", channelchangeChannelByNumberRequestInteractionInfo); - Map channelchangeChannelRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = - new CommandParameterInfo("match", String.class); - channelchangeChannelRequestCommandParams.put( - "match", channelchangeChannelRequestmatchCommandParameterInfo); - - InteractionInfo channelchangeChannelRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .changeChannelRequest( - (ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback, - (String) commandArguments.get("match")); - }, - () -> new DelegatedChangeChannelResponseCallback(), - channelchangeChannelRequestCommandParams); - channelClusterInteractionInfoMap.put( - "changeChannelRequest", channelchangeChannelRequestInteractionInfo); - Map channelskipChannelRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = - new CommandParameterInfo("count", Integer.class); - channelskipChannelRequestCommandParams.put( - "count", channelskipChannelRequestcountCommandParameterInfo); - - InteractionInfo channelskipChannelRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .skipChannelRequest( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("count")); - }, - () -> new DelegatedDefaultClusterCallback(), - channelskipChannelRequestCommandParams); - channelClusterInteractionInfoMap.put( - "skipChannelRequest", channelskipChannelRequestInteractionInfo); - commandMap.put("channel", channelClusterInteractionInfoMap); - Map colorControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map colorControlcolorLoopSetCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = - new CommandParameterInfo("updateFlags", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "updateFlags", colorControlcolorLoopSetupdateFlagsCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = - new CommandParameterInfo("action", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "action", colorControlcolorLoopSetactionCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = - new CommandParameterInfo("direction", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "direction", colorControlcolorLoopSetdirectionCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = - new CommandParameterInfo("time", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "time", colorControlcolorLoopSettimeCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = - new CommandParameterInfo("startHue", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "startHue", colorControlcolorLoopSetstartHueCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "optionsMask", colorControlcolorLoopSetoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "optionsOverride", colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlcolorLoopSetInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .colorLoopSet( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("updateFlags"), - (Integer) commandArguments.get("action"), - (Integer) commandArguments.get("direction"), - (Integer) commandArguments.get("time"), - (Integer) commandArguments.get("startHue"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlcolorLoopSetCommandParams); - colorControlClusterInteractionInfoMap.put( - "colorLoopSet", colorControlcolorLoopSetInteractionInfo); - Map colorControlenhancedMoveHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - colorControlenhancedMoveHueCommandParams.put( - "moveMode", colorControlenhancedMoveHuemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - colorControlenhancedMoveHueCommandParams.put( - "rate", colorControlenhancedMoveHuerateCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveHueCommandParams.put( - "optionsMask", colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveHueCommandParams.put( - "optionsOverride", colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveHueCommandParams); - colorControlClusterInteractionInfoMap.put( - "enhancedMoveHue", colorControlenhancedMoveHueInteractionInfo); - Map colorControlenhancedMoveToHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = - new CommandParameterInfo("enhancedHue", Integer.class); - colorControlenhancedMoveToHueCommandParams.put( - "enhancedHue", colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = - new CommandParameterInfo("direction", Integer.class); - colorControlenhancedMoveToHueCommandParams.put( - "direction", colorControlenhancedMoveToHuedirectionCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedMoveToHueCommandParams.put( - "transitionTime", colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveToHueCommandParams.put( - "optionsMask", colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveToHueCommandParams.put( - "optionsOverride", colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveToHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveToHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("enhancedHue"), - (Integer) commandArguments.get("direction"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveToHueCommandParams); - colorControlClusterInteractionInfoMap.put( - "enhancedMoveToHue", colorControlenhancedMoveToHueInteractionInfo); - Map colorControlenhancedMoveToHueAndSaturationCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = - new CommandParameterInfo("enhancedHue", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put( - "enhancedHue", colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = - new CommandParameterInfo("saturation", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put( - "saturation", colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); - - CommandParameterInfo - colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put( - "transitionTime", - colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put( - "optionsMask", colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo - colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put( - "optionsOverride", - colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveToHueAndSaturation( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("enhancedHue"), - (Integer) commandArguments.get("saturation"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveToHueAndSaturationCommandParams); - colorControlClusterInteractionInfoMap.put( - "enhancedMoveToHueAndSaturation", - colorControlenhancedMoveToHueAndSaturationInteractionInfo); - Map colorControlenhancedStepHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - colorControlenhancedStepHueCommandParams.put( - "stepMode", colorControlenhancedStepHuestepModeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - colorControlenhancedStepHueCommandParams.put( - "stepSize", colorControlenhancedStepHuestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedStepHueCommandParams.put( - "transitionTime", colorControlenhancedStepHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedStepHueCommandParams.put( - "optionsMask", colorControlenhancedStepHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedStepHueCommandParams.put( - "optionsOverride", colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedStepHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedStepHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedStepHueCommandParams); - colorControlClusterInteractionInfoMap.put( - "enhancedStepHue", colorControlenhancedStepHueInteractionInfo); - Map colorControlmoveColorCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = - new CommandParameterInfo("rateX", Integer.class); - colorControlmoveColorCommandParams.put("rateX", colorControlmoveColorrateXCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = - new CommandParameterInfo("rateY", Integer.class); - colorControlmoveColorCommandParams.put("rateY", colorControlmoveColorrateYCommandParameterInfo); - - CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveColorCommandParams.put( - "optionsMask", colorControlmoveColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveColorCommandParams.put( - "optionsOverride", colorControlmoveColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveColorInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveColor( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("rateX"), - (Integer) commandArguments.get("rateY"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveColorCommandParams); - colorControlClusterInteractionInfoMap.put("moveColor", colorControlmoveColorInteractionInfo); - Map colorControlmoveColorTemperatureCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "moveMode", colorControlmoveColorTemperaturemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "rate", colorControlmoveColorTemperaturerateCommandParameterInfo); - - CommandParameterInfo - colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = - new CommandParameterInfo("colorTemperatureMinimum", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "colorTemperatureMinimum", - colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - - CommandParameterInfo - colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = - new CommandParameterInfo("colorTemperatureMaximum", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "colorTemperatureMaximum", - colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "optionsMask", colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "optionsOverride", colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveColorTemperatureInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveColorTemperature( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate"), - (Integer) commandArguments.get("colorTemperatureMinimum"), - (Integer) commandArguments.get("colorTemperatureMaximum"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveColorTemperatureCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveColorTemperature", colorControlmoveColorTemperatureInteractionInfo); - Map colorControlmoveHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveHueCommandParams.put( - "moveMode", colorControlmoveHuemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - colorControlmoveHueCommandParams.put("rate", colorControlmoveHuerateCommandParameterInfo); - - CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveHueCommandParams.put( - "optionsMask", colorControlmoveHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveHueCommandParams.put( - "optionsOverride", colorControlmoveHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveHueCommandParams); - colorControlClusterInteractionInfoMap.put("moveHue", colorControlmoveHueInteractionInfo); - Map colorControlmoveSaturationCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveSaturationCommandParams.put( - "moveMode", colorControlmoveSaturationmoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - colorControlmoveSaturationCommandParams.put( - "rate", colorControlmoveSaturationrateCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveSaturationCommandParams.put( - "optionsMask", colorControlmoveSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveSaturationCommandParams.put( - "optionsOverride", colorControlmoveSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveSaturationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveSaturation( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveSaturationCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveSaturation", colorControlmoveSaturationInteractionInfo); - Map colorControlmoveToColorCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = - new CommandParameterInfo("colorX", Integer.class); - colorControlmoveToColorCommandParams.put( - "colorX", colorControlmoveToColorcolorXCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = - new CommandParameterInfo("colorY", Integer.class); - colorControlmoveToColorCommandParams.put( - "colorY", colorControlmoveToColorcolorYCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToColorCommandParams.put( - "transitionTime", colorControlmoveToColortransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToColorCommandParams.put( - "optionsMask", colorControlmoveToColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToColorCommandParams.put( - "optionsOverride", colorControlmoveToColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToColorInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToColor( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("colorX"), - (Integer) commandArguments.get("colorY"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToColorCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveToColor", colorControlmoveToColorInteractionInfo); - Map colorControlmoveToColorTemperatureCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = - new CommandParameterInfo("colorTemperature", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put( - "colorTemperature", colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put( - "transitionTime", colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put( - "optionsMask", colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put( - "optionsOverride", colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToColorTemperature( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("colorTemperature"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToColorTemperatureCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveToColorTemperature", colorControlmoveToColorTemperatureInteractionInfo); - Map colorControlmoveToHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = - new CommandParameterInfo("hue", Integer.class); - colorControlmoveToHueCommandParams.put("hue", colorControlmoveToHuehueCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = - new CommandParameterInfo("direction", Integer.class); - colorControlmoveToHueCommandParams.put( - "direction", colorControlmoveToHuedirectionCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToHueCommandParams.put( - "transitionTime", colorControlmoveToHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToHueCommandParams.put( - "optionsMask", colorControlmoveToHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToHueCommandParams.put( - "optionsOverride", colorControlmoveToHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("hue"), - (Integer) commandArguments.get("direction"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToHueCommandParams); - colorControlClusterInteractionInfoMap.put("moveToHue", colorControlmoveToHueInteractionInfo); - Map colorControlmoveToHueAndSaturationCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = - new CommandParameterInfo("hue", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put( - "hue", colorControlmoveToHueAndSaturationhueCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = - new CommandParameterInfo("saturation", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put( - "saturation", colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put( - "transitionTime", colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put( - "optionsMask", colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put( - "optionsOverride", colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToHueAndSaturation( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("hue"), - (Integer) commandArguments.get("saturation"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToHueAndSaturationCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveToHueAndSaturation", colorControlmoveToHueAndSaturationInteractionInfo); - Map colorControlmoveToSaturationCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = - new CommandParameterInfo("saturation", Integer.class); - colorControlmoveToSaturationCommandParams.put( - "saturation", colorControlmoveToSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToSaturationCommandParams.put( - "transitionTime", colorControlmoveToSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToSaturationCommandParams.put( - "optionsMask", colorControlmoveToSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToSaturationCommandParams.put( - "optionsOverride", colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToSaturationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToSaturation( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("saturation"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToSaturationCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveToSaturation", colorControlmoveToSaturationInteractionInfo); - Map colorControlstepColorCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = - new CommandParameterInfo("stepX", Integer.class); - colorControlstepColorCommandParams.put("stepX", colorControlstepColorstepXCommandParameterInfo); - - CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = - new CommandParameterInfo("stepY", Integer.class); - colorControlstepColorCommandParams.put("stepY", colorControlstepColorstepYCommandParameterInfo); - - CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepColorCommandParams.put( - "transitionTime", colorControlstepColortransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepColorCommandParams.put( - "optionsMask", colorControlstepColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepColorCommandParams.put( - "optionsOverride", colorControlstepColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepColorInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepColor( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepX"), - (Integer) commandArguments.get("stepY"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepColorCommandParams); - colorControlClusterInteractionInfoMap.put("stepColor", colorControlstepColorInteractionInfo); - Map colorControlstepColorTemperatureCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "stepMode", colorControlstepColorTemperaturestepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "stepSize", colorControlstepColorTemperaturestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "transitionTime", colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); - - CommandParameterInfo - colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = - new CommandParameterInfo("colorTemperatureMinimum", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "colorTemperatureMinimum", - colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - - CommandParameterInfo - colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = - new CommandParameterInfo("colorTemperatureMaximum", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "colorTemperatureMaximum", - colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "optionsMask", colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "optionsOverride", colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepColorTemperatureInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepColorTemperature( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("colorTemperatureMinimum"), - (Integer) commandArguments.get("colorTemperatureMaximum"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepColorTemperatureCommandParams); - colorControlClusterInteractionInfoMap.put( - "stepColorTemperature", colorControlstepColorTemperatureInteractionInfo); - Map colorControlstepHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - colorControlstepHueCommandParams.put( - "stepMode", colorControlstepHuestepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - colorControlstepHueCommandParams.put( - "stepSize", colorControlstepHuestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepHueCommandParams.put( - "transitionTime", colorControlstepHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepHueCommandParams.put( - "optionsMask", colorControlstepHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepHueCommandParams.put( - "optionsOverride", colorControlstepHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepHueCommandParams); - colorControlClusterInteractionInfoMap.put("stepHue", colorControlstepHueInteractionInfo); - Map colorControlstepSaturationCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - colorControlstepSaturationCommandParams.put( - "stepMode", colorControlstepSaturationstepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - colorControlstepSaturationCommandParams.put( - "stepSize", colorControlstepSaturationstepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepSaturationCommandParams.put( - "transitionTime", colorControlstepSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepSaturationCommandParams.put( - "optionsMask", colorControlstepSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepSaturationCommandParams.put( - "optionsOverride", colorControlstepSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepSaturationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepSaturation( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepSaturationCommandParams); - colorControlClusterInteractionInfoMap.put( - "stepSaturation", colorControlstepSaturationInteractionInfo); - Map colorControlstopMoveStepCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlstopMoveStepCommandParams.put( - "optionsMask", colorControlstopMoveStepoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstopMoveStepCommandParams.put( - "optionsOverride", colorControlstopMoveStepoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstopMoveStepInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stopMoveStep( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstopMoveStepCommandParams); - colorControlClusterInteractionInfoMap.put( - "stopMoveStep", colorControlstopMoveStepInteractionInfo); - commandMap.put("colorControl", colorControlClusterInteractionInfoMap); - Map contentLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); - Map contentLauncherlaunchContentRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = - new CommandParameterInfo("autoPlay", Boolean.class); - contentLauncherlaunchContentRequestCommandParams.put( - "autoPlay", contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); - - CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = - new CommandParameterInfo("data", String.class); - contentLauncherlaunchContentRequestCommandParams.put( - "data", contentLauncherlaunchContentRequestdataCommandParameterInfo); - - InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .launchContentRequest( - (ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback, - (Boolean) commandArguments.get("autoPlay"), - (String) commandArguments.get("data"), - (ArrayList) - commandArguments.get("search")); - }, - () -> new DelegatedLaunchResponseCallback(), - contentLauncherlaunchContentRequestCommandParams); - contentLauncherClusterInteractionInfoMap.put( - "launchContentRequest", contentLauncherlaunchContentRequestInteractionInfo); - Map contentLauncherlaunchURLRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = - new CommandParameterInfo("contentURL", String.class); - contentLauncherlaunchURLRequestCommandParams.put( - "contentURL", contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); - - CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = - new CommandParameterInfo("displayString", String.class); - contentLauncherlaunchURLRequestCommandParams.put( - "displayString", contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); - - InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .launchURLRequest( - (ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback, - (String) commandArguments.get("contentURL"), - (String) commandArguments.get("displayString"), - (ChipStructs.ContentLauncherClusterBrandingInformation) - commandArguments.get("brandingInformation")); - }, - () -> new DelegatedLaunchResponseCallback(), - contentLauncherlaunchURLRequestCommandParams); - contentLauncherClusterInteractionInfoMap.put( - "launchURLRequest", contentLauncherlaunchURLRequestInteractionInfo); - commandMap.put("contentLauncher", contentLauncherClusterInteractionInfoMap); - Map descriptorClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("descriptor", descriptorClusterInteractionInfoMap); - Map diagnosticLogsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map diagnosticLogsretrieveLogsRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = - new CommandParameterInfo("intent", Integer.class); - diagnosticLogsretrieveLogsRequestCommandParams.put( - "intent", diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); - - CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = - new CommandParameterInfo("requestedProtocol", Integer.class); - diagnosticLogsretrieveLogsRequestCommandParams.put( - "requestedProtocol", - diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); - - CommandParameterInfo - diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = - new CommandParameterInfo("transferFileDesignator", byte[].class); - diagnosticLogsretrieveLogsRequestCommandParams.put( - "transferFileDesignator", - diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); - - InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .retrieveLogsRequest( - (ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback) callback, - (Integer) commandArguments.get("intent"), - (Integer) commandArguments.get("requestedProtocol"), - (byte[]) commandArguments.get("transferFileDesignator")); - }, - () -> new DelegatedRetrieveLogsResponseCallback(), - diagnosticLogsretrieveLogsRequestCommandParams); - diagnosticLogsClusterInteractionInfoMap.put( - "retrieveLogsRequest", diagnosticLogsretrieveLogsRequestInteractionInfo); - commandMap.put("diagnosticLogs", diagnosticLogsClusterInteractionInfoMap); - Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); - Map doorLockclearCredentialCommandParams = - new LinkedHashMap(); - InteractionInfo doorLockclearCredentialInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearCredential( - (DefaultClusterCallback) callback, - (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearCredentialCommandParams); - doorLockClusterInteractionInfoMap.put( - "clearCredential", doorLockclearCredentialInteractionInfo); - Map doorLockclearUserCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockclearUserCommandParams.put("userIndex", doorLockclearUseruserIndexCommandParameterInfo); - - InteractionInfo doorLockclearUserInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearUser( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("userIndex"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearUserCommandParams); - doorLockClusterInteractionInfoMap.put("clearUser", doorLockclearUserInteractionInfo); - Map doorLockclearWeekDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = - new CommandParameterInfo("weekDayIndex", Integer.class); - doorLockclearWeekDayScheduleCommandParams.put( - "weekDayIndex", doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockclearWeekDayScheduleCommandParams.put( - "userIndex", doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearWeekDaySchedule( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("weekDayIndex"), - (Integer) commandArguments.get("userIndex")); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearWeekDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "clearWeekDaySchedule", doorLockclearWeekDayScheduleInteractionInfo); - Map doorLockclearYearDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = - new CommandParameterInfo("yearDayIndex", Integer.class); - doorLockclearYearDayScheduleCommandParams.put( - "yearDayIndex", doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockclearYearDayScheduleCommandParams.put( - "userIndex", doorLockclearYearDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockclearYearDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearYearDaySchedule( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("yearDayIndex"), - (Integer) commandArguments.get("userIndex")); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearYearDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "clearYearDaySchedule", doorLockclearYearDayScheduleInteractionInfo); - Map doorLockgetCredentialStatusCommandParams = - new LinkedHashMap(); - InteractionInfo doorLockgetCredentialStatusInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getCredentialStatus( - (ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback, - (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential")); - }, - () -> new DelegatedGetCredentialStatusResponseCallback(), - doorLockgetCredentialStatusCommandParams); - doorLockClusterInteractionInfoMap.put( - "getCredentialStatus", doorLockgetCredentialStatusInteractionInfo); - Map doorLockgetUserCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockgetUserCommandParams.put("userIndex", doorLockgetUseruserIndexCommandParameterInfo); - - InteractionInfo doorLockgetUserInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getUser( - (ChipClusters.DoorLockCluster.GetUserResponseCallback) callback, - (Integer) commandArguments.get("userIndex")); - }, - () -> new DelegatedGetUserResponseCallback(), - doorLockgetUserCommandParams); - doorLockClusterInteractionInfoMap.put("getUser", doorLockgetUserInteractionInfo); - Map doorLockgetWeekDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = - new CommandParameterInfo("weekDayIndex", Integer.class); - doorLockgetWeekDayScheduleCommandParams.put( - "weekDayIndex", doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockgetWeekDayScheduleCommandParams.put( - "userIndex", doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getWeekDaySchedule( - (ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback) callback, - (Integer) commandArguments.get("weekDayIndex"), - (Integer) commandArguments.get("userIndex")); - }, - () -> new DelegatedGetWeekDayScheduleResponseCallback(), - doorLockgetWeekDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "getWeekDaySchedule", doorLockgetWeekDayScheduleInteractionInfo); - Map doorLockgetYearDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = - new CommandParameterInfo("yearDayIndex", Integer.class); - doorLockgetYearDayScheduleCommandParams.put( - "yearDayIndex", doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockgetYearDayScheduleCommandParams.put( - "userIndex", doorLockgetYearDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockgetYearDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getYearDaySchedule( - (ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback) callback, - (Integer) commandArguments.get("yearDayIndex"), - (Integer) commandArguments.get("userIndex")); - }, - () -> new DelegatedGetYearDayScheduleResponseCallback(), - doorLockgetYearDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "getYearDaySchedule", doorLockgetYearDayScheduleInteractionInfo); - Map doorLocklockDoorCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = - new CommandParameterInfo("pinCode", Optional.class); - doorLocklockDoorCommandParams.put("pinCode", doorLocklockDoorpinCodeCommandParameterInfo); - - InteractionInfo doorLocklockDoorInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .lockDoor( - (DefaultClusterCallback) callback, - (Optional) commandArguments.get("pinCode"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocklockDoorCommandParams); - doorLockClusterInteractionInfoMap.put("lockDoor", doorLocklockDoorInteractionInfo); - Map doorLocksetCredentialCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = - new CommandParameterInfo("operationType", Integer.class); - doorLocksetCredentialCommandParams.put( - "operationType", doorLocksetCredentialoperationTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = - new CommandParameterInfo("credentialData", byte[].class); - doorLocksetCredentialCommandParams.put( - "credentialData", doorLocksetCredentialcredentialDataCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLocksetCredentialCommandParams.put( - "userIndex", doorLocksetCredentialuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = - new CommandParameterInfo("userStatus", Integer.class); - doorLocksetCredentialCommandParams.put( - "userStatus", doorLocksetCredentialuserStatusCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = - new CommandParameterInfo("userType", Integer.class); - doorLocksetCredentialCommandParams.put( - "userType", doorLocksetCredentialuserTypeCommandParameterInfo); - - InteractionInfo doorLocksetCredentialInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setCredential( - (ChipClusters.DoorLockCluster.SetCredentialResponseCallback) callback, - (Integer) commandArguments.get("operationType"), - (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential"), - (byte[]) commandArguments.get("credentialData"), - (Integer) commandArguments.get("userIndex"), - (Integer) commandArguments.get("userStatus"), - (Integer) commandArguments.get("userType"), - 10000); - }, - () -> new DelegatedSetCredentialResponseCallback(), - doorLocksetCredentialCommandParams); - doorLockClusterInteractionInfoMap.put("setCredential", doorLocksetCredentialInteractionInfo); - Map doorLocksetUserCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = - new CommandParameterInfo("operationType", Integer.class); - doorLocksetUserCommandParams.put( - "operationType", doorLocksetUseroperationTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLocksetUserCommandParams.put("userIndex", doorLocksetUseruserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = - new CommandParameterInfo("userName", String.class); - doorLocksetUserCommandParams.put("userName", doorLocksetUseruserNameCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = - new CommandParameterInfo("userUniqueId", Long.class); - doorLocksetUserCommandParams.put( - "userUniqueId", doorLocksetUseruserUniqueIdCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = - new CommandParameterInfo("userStatus", Integer.class); - doorLocksetUserCommandParams.put("userStatus", doorLocksetUseruserStatusCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = - new CommandParameterInfo("userType", Integer.class); - doorLocksetUserCommandParams.put("userType", doorLocksetUseruserTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = - new CommandParameterInfo("credentialRule", Integer.class); - doorLocksetUserCommandParams.put( - "credentialRule", doorLocksetUsercredentialRuleCommandParameterInfo); - - InteractionInfo doorLocksetUserInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setUser( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("operationType"), - (Integer) commandArguments.get("userIndex"), - (String) commandArguments.get("userName"), - (Long) commandArguments.get("userUniqueId"), - (Integer) commandArguments.get("userStatus"), - (Integer) commandArguments.get("userType"), - (Integer) commandArguments.get("credentialRule"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetUserCommandParams); - doorLockClusterInteractionInfoMap.put("setUser", doorLocksetUserInteractionInfo); - Map doorLocksetWeekDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = - new CommandParameterInfo("weekDayIndex", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "weekDayIndex", doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "userIndex", doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = - new CommandParameterInfo("daysMask", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "daysMask", doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = - new CommandParameterInfo("startHour", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "startHour", doorLocksetWeekDaySchedulestartHourCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = - new CommandParameterInfo("startMinute", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "startMinute", doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = - new CommandParameterInfo("endHour", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "endHour", doorLocksetWeekDayScheduleendHourCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = - new CommandParameterInfo("endMinute", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "endMinute", doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); - - InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setWeekDaySchedule( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("weekDayIndex"), - (Integer) commandArguments.get("userIndex"), - (Integer) commandArguments.get("daysMask"), - (Integer) commandArguments.get("startHour"), - (Integer) commandArguments.get("startMinute"), - (Integer) commandArguments.get("endHour"), - (Integer) commandArguments.get("endMinute")); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetWeekDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "setWeekDaySchedule", doorLocksetWeekDayScheduleInteractionInfo); - Map doorLocksetYearDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = - new CommandParameterInfo("yearDayIndex", Integer.class); - doorLocksetYearDayScheduleCommandParams.put( - "yearDayIndex", doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLocksetYearDayScheduleCommandParams.put( - "userIndex", doorLocksetYearDayScheduleuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = - new CommandParameterInfo("localStartTime", Long.class); - doorLocksetYearDayScheduleCommandParams.put( - "localStartTime", doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = - new CommandParameterInfo("localEndTime", Long.class); - doorLocksetYearDayScheduleCommandParams.put( - "localEndTime", doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); - - InteractionInfo doorLocksetYearDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setYearDaySchedule( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("yearDayIndex"), - (Integer) commandArguments.get("userIndex"), - (Long) commandArguments.get("localStartTime"), - (Long) commandArguments.get("localEndTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetYearDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "setYearDaySchedule", doorLocksetYearDayScheduleInteractionInfo); - Map doorLockunlockDoorCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = - new CommandParameterInfo("pinCode", Optional.class); - doorLockunlockDoorCommandParams.put("pinCode", doorLockunlockDoorpinCodeCommandParameterInfo); - - InteractionInfo doorLockunlockDoorInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .unlockDoor( - (DefaultClusterCallback) callback, - (Optional) commandArguments.get("pinCode"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockunlockDoorCommandParams); - doorLockClusterInteractionInfoMap.put("unlockDoor", doorLockunlockDoorInteractionInfo); - Map doorLockunlockWithTimeoutCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = - new CommandParameterInfo("timeout", Integer.class); - doorLockunlockWithTimeoutCommandParams.put( - "timeout", doorLockunlockWithTimeouttimeoutCommandParameterInfo); - - CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = - new CommandParameterInfo("pinCode", Optional.class); - doorLockunlockWithTimeoutCommandParams.put( - "pinCode", doorLockunlockWithTimeoutpinCodeCommandParameterInfo); - - InteractionInfo doorLockunlockWithTimeoutInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .unlockWithTimeout( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("timeout"), - (Optional) commandArguments.get("pinCode"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockunlockWithTimeoutCommandParams); - doorLockClusterInteractionInfoMap.put( - "unlockWithTimeout", doorLockunlockWithTimeoutInteractionInfo); - commandMap.put("doorLock", doorLockClusterInteractionInfoMap); - Map electricalMeasurementClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("electricalMeasurement", electricalMeasurementClusterInteractionInfoMap); - Map ethernetNetworkDiagnosticsClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map ethernetNetworkDiagnosticsresetCountsCommandParams = - new LinkedHashMap(); - InteractionInfo ethernetNetworkDiagnosticsresetCountsInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - ethernetNetworkDiagnosticsresetCountsCommandParams); - ethernetNetworkDiagnosticsClusterInteractionInfoMap.put( - "resetCounts", ethernetNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put( - "ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); - Map fixedLabelClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("fixedLabel", fixedLabelClusterInteractionInfoMap); - Map flowMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("flowMeasurement", flowMeasurementClusterInteractionInfoMap); - Map generalCommissioningClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map generalCommissioningarmFailSafeCommandParams = - new LinkedHashMap(); - CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = - new CommandParameterInfo("expiryLengthSeconds", Integer.class); - generalCommissioningarmFailSafeCommandParams.put( - "expiryLengthSeconds", - generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); - - CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - generalCommissioningarmFailSafeCommandParams.put( - "breadcrumb", generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); - - CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = - new CommandParameterInfo("timeoutMs", Long.class); - generalCommissioningarmFailSafeCommandParams.put( - "timeoutMs", generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); - - InteractionInfo generalCommissioningarmFailSafeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .armFailSafe( - (ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback) - callback, - (Integer) commandArguments.get("expiryLengthSeconds"), - (Long) commandArguments.get("breadcrumb"), - (Long) commandArguments.get("timeoutMs")); - }, - () -> new DelegatedArmFailSafeResponseCallback(), - generalCommissioningarmFailSafeCommandParams); - generalCommissioningClusterInteractionInfoMap.put( - "armFailSafe", generalCommissioningarmFailSafeInteractionInfo); - Map generalCommissioningcommissioningCompleteCommandParams = - new LinkedHashMap(); - InteractionInfo generalCommissioningcommissioningCompleteInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .commissioningComplete( - (ChipClusters.GeneralCommissioningCluster - .CommissioningCompleteResponseCallback) - callback); - }, - () -> new DelegatedCommissioningCompleteResponseCallback(), - generalCommissioningcommissioningCompleteCommandParams); - generalCommissioningClusterInteractionInfoMap.put( - "commissioningComplete", generalCommissioningcommissioningCompleteInteractionInfo); - Map generalCommissioningsetRegulatoryConfigCommandParams = - new LinkedHashMap(); - CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = - new CommandParameterInfo("location", Integer.class); - generalCommissioningsetRegulatoryConfigCommandParams.put( - "location", generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = - new CommandParameterInfo("countryCode", String.class); - generalCommissioningsetRegulatoryConfigCommandParams.put( - "countryCode", generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - generalCommissioningsetRegulatoryConfigCommandParams.put( - "breadcrumb", generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = - new CommandParameterInfo("timeoutMs", Long.class); - generalCommissioningsetRegulatoryConfigCommandParams.put( - "timeoutMs", generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); - - InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .setRegulatoryConfig( - (ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback) - callback, - (Integer) commandArguments.get("location"), - (String) commandArguments.get("countryCode"), - (Long) commandArguments.get("breadcrumb"), - (Long) commandArguments.get("timeoutMs")); - }, - () -> new DelegatedSetRegulatoryConfigResponseCallback(), - generalCommissioningsetRegulatoryConfigCommandParams); - generalCommissioningClusterInteractionInfoMap.put( - "setRegulatoryConfig", generalCommissioningsetRegulatoryConfigInteractionInfo); - commandMap.put("generalCommissioning", generalCommissioningClusterInteractionInfoMap); - Map generalDiagnosticsClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("generalDiagnostics", generalDiagnosticsClusterInteractionInfoMap); - Map groupKeyManagementClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map groupKeyManagementkeySetReadCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = - new CommandParameterInfo("groupKeySetID", Integer.class); - groupKeyManagementkeySetReadCommandParams.put( - "groupKeySetID", groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetReadInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetRead( - (ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback, - (Integer) commandArguments.get("groupKeySetID")); - }, - () -> new DelegatedKeySetReadResponseCallback(), - groupKeyManagementkeySetReadCommandParams); - groupKeyManagementClusterInteractionInfoMap.put( - "keySetRead", groupKeyManagementkeySetReadInteractionInfo); - Map groupKeyManagementkeySetReadAllIndicesCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = - new CommandParameterInfo("groupKeySetIDs", ArrayList.class); - groupKeyManagementkeySetReadAllIndicesCommandParams.put( - "groupKeySetIDs", groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetReadAllIndices( - (ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) - callback, - (ArrayList) commandArguments.get("groupKeySetIDs")); - }, - () -> new DelegatedKeySetReadAllIndicesResponseCallback(), - groupKeyManagementkeySetReadAllIndicesCommandParams); - groupKeyManagementClusterInteractionInfoMap.put( - "keySetReadAllIndices", groupKeyManagementkeySetReadAllIndicesInteractionInfo); - Map groupKeyManagementkeySetRemoveCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = - new CommandParameterInfo("groupKeySetID", Integer.class); - groupKeyManagementkeySetRemoveCommandParams.put( - "groupKeySetID", groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetRemove( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("groupKeySetID")); - }, - () -> new DelegatedDefaultClusterCallback(), - groupKeyManagementkeySetRemoveCommandParams); - groupKeyManagementClusterInteractionInfoMap.put( - "keySetRemove", groupKeyManagementkeySetRemoveInteractionInfo); - Map groupKeyManagementkeySetWriteCommandParams = - new LinkedHashMap(); - InteractionInfo groupKeyManagementkeySetWriteInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetWrite( - (DefaultClusterCallback) callback, - (ChipStructs.GroupKeyManagementClusterGroupKeySet) - commandArguments.get("groupKeySet")); - }, - () -> new DelegatedDefaultClusterCallback(), - groupKeyManagementkeySetWriteCommandParams); - groupKeyManagementClusterInteractionInfoMap.put( - "keySetWrite", groupKeyManagementkeySetWriteInteractionInfo); - commandMap.put("groupKeyManagement", groupKeyManagementClusterInteractionInfoMap); - Map groupsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map groupsaddGroupCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - groupsaddGroupCommandParams.put("groupId", groupsaddGroupgroupIdCommandParameterInfo); - - CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = - new CommandParameterInfo("groupName", String.class); - groupsaddGroupCommandParams.put("groupName", groupsaddGroupgroupNameCommandParameterInfo); - - InteractionInfo groupsaddGroupInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .addGroup( - (ChipClusters.GroupsCluster.AddGroupResponseCallback) callback, - (Integer) commandArguments.get("groupId"), - (String) commandArguments.get("groupName")); - }, - () -> new DelegatedAddGroupResponseCallback(), - groupsaddGroupCommandParams); - groupsClusterInteractionInfoMap.put("addGroup", groupsaddGroupInteractionInfo); - Map groupsaddGroupIfIdentifyingCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - groupsaddGroupIfIdentifyingCommandParams.put( - "groupId", groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); - - CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = - new CommandParameterInfo("groupName", String.class); - groupsaddGroupIfIdentifyingCommandParams.put( - "groupName", groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); - - InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .addGroupIfIdentifying( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("groupId"), - (String) commandArguments.get("groupName")); - }, - () -> new DelegatedDefaultClusterCallback(), - groupsaddGroupIfIdentifyingCommandParams); - groupsClusterInteractionInfoMap.put( - "addGroupIfIdentifying", groupsaddGroupIfIdentifyingInteractionInfo); - Map groupsgetGroupMembershipCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = - new CommandParameterInfo("groupList", ArrayList.class); - groupsgetGroupMembershipCommandParams.put( - "groupList", groupsgetGroupMembershipgroupListCommandParameterInfo); - - InteractionInfo groupsgetGroupMembershipInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .getGroupMembership( - (ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback, - (ArrayList) commandArguments.get("groupList")); - }, - () -> new DelegatedGetGroupMembershipResponseCallback(), - groupsgetGroupMembershipCommandParams); - groupsClusterInteractionInfoMap.put( - "getGroupMembership", groupsgetGroupMembershipInteractionInfo); - Map groupsremoveAllGroupsCommandParams = - new LinkedHashMap(); - InteractionInfo groupsremoveAllGroupsInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .removeAllGroups((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - groupsremoveAllGroupsCommandParams); - groupsClusterInteractionInfoMap.put("removeAllGroups", groupsremoveAllGroupsInteractionInfo); - Map groupsremoveGroupCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - groupsremoveGroupCommandParams.put("groupId", groupsremoveGroupgroupIdCommandParameterInfo); - - InteractionInfo groupsremoveGroupInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .removeGroup( - (ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback, - (Integer) commandArguments.get("groupId")); - }, - () -> new DelegatedRemoveGroupResponseCallback(), - groupsremoveGroupCommandParams); - groupsClusterInteractionInfoMap.put("removeGroup", groupsremoveGroupInteractionInfo); - Map groupsviewGroupCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - groupsviewGroupCommandParams.put("groupId", groupsviewGroupgroupIdCommandParameterInfo); - - InteractionInfo groupsviewGroupInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .viewGroup( - (ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback, - (Integer) commandArguments.get("groupId")); - }, - () -> new DelegatedViewGroupResponseCallback(), - groupsviewGroupCommandParams); - groupsClusterInteractionInfoMap.put("viewGroup", groupsviewGroupInteractionInfo); - commandMap.put("groups", groupsClusterInteractionInfoMap); - Map identifyClusterInteractionInfoMap = new LinkedHashMap<>(); - Map identifyidentifyCommandParams = - new LinkedHashMap(); - CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = - new CommandParameterInfo("identifyTime", Integer.class); - identifyidentifyCommandParams.put( - "identifyTime", identifyidentifyidentifyTimeCommandParameterInfo); - - InteractionInfo identifyidentifyInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .identify( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("identifyTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - identifyidentifyCommandParams); - identifyClusterInteractionInfoMap.put("identify", identifyidentifyInteractionInfo); - Map identifyidentifyQueryCommandParams = - new LinkedHashMap(); - InteractionInfo identifyidentifyQueryInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .identifyQuery( - (ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback); - }, - () -> new DelegatedIdentifyQueryResponseCallback(), - identifyidentifyQueryCommandParams); - identifyClusterInteractionInfoMap.put("identifyQuery", identifyidentifyQueryInteractionInfo); - Map identifytriggerEffectCommandParams = - new LinkedHashMap(); - CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = - new CommandParameterInfo("effectIdentifier", Integer.class); - identifytriggerEffectCommandParams.put( - "effectIdentifier", identifytriggerEffecteffectIdentifierCommandParameterInfo); - - CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = - new CommandParameterInfo("effectVariant", Integer.class); - identifytriggerEffectCommandParams.put( - "effectVariant", identifytriggerEffecteffectVariantCommandParameterInfo); - - InteractionInfo identifytriggerEffectInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .triggerEffect( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("effectIdentifier"), - (Integer) commandArguments.get("effectVariant")); - }, - () -> new DelegatedDefaultClusterCallback(), - identifytriggerEffectCommandParams); - identifyClusterInteractionInfoMap.put("triggerEffect", identifytriggerEffectInteractionInfo); - commandMap.put("identify", identifyClusterInteractionInfoMap); - Map illuminanceMeasurementClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInteractionInfoMap); - Map keypadInputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map keypadInputsendKeyRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = - new CommandParameterInfo("keyCode", Integer.class); - keypadInputsendKeyRequestCommandParams.put( - "keyCode", keypadInputsendKeyRequestkeyCodeCommandParameterInfo); - - InteractionInfo keypadInputsendKeyRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .sendKeyRequest( - (ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback, - (Integer) commandArguments.get("keyCode")); - }, - () -> new DelegatedSendKeyResponseCallback(), - keypadInputsendKeyRequestCommandParams); - keypadInputClusterInteractionInfoMap.put( - "sendKeyRequest", keypadInputsendKeyRequestInteractionInfo); - commandMap.put("keypadInput", keypadInputClusterInteractionInfoMap); - Map levelControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map levelControlmoveCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - levelControlmoveCommandParams.put("moveMode", levelControlmovemoveModeCommandParameterInfo); - - CommandParameterInfo levelControlmoverateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - levelControlmoveCommandParams.put("rate", levelControlmoverateCommandParameterInfo); - - CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = - new CommandParameterInfo("optionMask", Integer.class); - levelControlmoveCommandParams.put("optionMask", levelControlmoveoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = - new CommandParameterInfo("optionOverride", Integer.class); - levelControlmoveCommandParams.put( - "optionOverride", levelControlmoveoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlmoveInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .move( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate"), - (Integer) commandArguments.get("optionMask"), - (Integer) commandArguments.get("optionOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveCommandParams); - levelControlClusterInteractionInfoMap.put("move", levelControlmoveInteractionInfo); - Map levelControlmoveToLevelCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = - new CommandParameterInfo("level", Integer.class); - levelControlmoveToLevelCommandParams.put( - "level", levelControlmoveToLevellevelCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - levelControlmoveToLevelCommandParams.put( - "transitionTime", levelControlmoveToLeveltransitionTimeCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = - new CommandParameterInfo("optionMask", Integer.class); - levelControlmoveToLevelCommandParams.put( - "optionMask", levelControlmoveToLeveloptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = - new CommandParameterInfo("optionOverride", Integer.class); - levelControlmoveToLevelCommandParams.put( - "optionOverride", levelControlmoveToLeveloptionOverrideCommandParameterInfo); - - InteractionInfo levelControlmoveToLevelInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveToLevel( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("level"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionMask"), - (Integer) commandArguments.get("optionOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveToLevelCommandParams); - levelControlClusterInteractionInfoMap.put( - "moveToLevel", levelControlmoveToLevelInteractionInfo); - Map levelControlmoveToLevelWithOnOffCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = - new CommandParameterInfo("level", Integer.class); - levelControlmoveToLevelWithOnOffCommandParams.put( - "level", levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - levelControlmoveToLevelWithOnOffCommandParams.put( - "transitionTime", levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); - - InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveToLevelWithOnOff( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("level"), - (Integer) commandArguments.get("transitionTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveToLevelWithOnOffCommandParams); - levelControlClusterInteractionInfoMap.put( - "moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffInteractionInfo); - Map levelControlmoveWithOnOffCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - levelControlmoveWithOnOffCommandParams.put( - "moveMode", levelControlmoveWithOnOffmoveModeCommandParameterInfo); - - CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - levelControlmoveWithOnOffCommandParams.put( - "rate", levelControlmoveWithOnOffrateCommandParameterInfo); - - InteractionInfo levelControlmoveWithOnOffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveWithOnOff( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveWithOnOffCommandParams); - levelControlClusterInteractionInfoMap.put( - "moveWithOnOff", levelControlmoveWithOnOffInteractionInfo); - Map levelControlstepCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlstepstepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - levelControlstepCommandParams.put("stepMode", levelControlstepstepModeCommandParameterInfo); - - CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - levelControlstepCommandParams.put("stepSize", levelControlstepstepSizeCommandParameterInfo); - - CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - levelControlstepCommandParams.put( - "transitionTime", levelControlsteptransitionTimeCommandParameterInfo); - - CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = - new CommandParameterInfo("optionMask", Integer.class); - levelControlstepCommandParams.put("optionMask", levelControlstepoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = - new CommandParameterInfo("optionOverride", Integer.class); - levelControlstepCommandParams.put( - "optionOverride", levelControlstepoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlstepInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .step( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionMask"), - (Integer) commandArguments.get("optionOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstepCommandParams); - levelControlClusterInteractionInfoMap.put("step", levelControlstepInteractionInfo); - Map levelControlstepWithOnOffCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - levelControlstepWithOnOffCommandParams.put( - "stepMode", levelControlstepWithOnOffstepModeCommandParameterInfo); - - CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - levelControlstepWithOnOffCommandParams.put( - "stepSize", levelControlstepWithOnOffstepSizeCommandParameterInfo); - - CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - levelControlstepWithOnOffCommandParams.put( - "transitionTime", levelControlstepWithOnOfftransitionTimeCommandParameterInfo); - - InteractionInfo levelControlstepWithOnOffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stepWithOnOff( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstepWithOnOffCommandParams); - levelControlClusterInteractionInfoMap.put( - "stepWithOnOff", levelControlstepWithOnOffInteractionInfo); - Map levelControlstopCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = - new CommandParameterInfo("optionMask", Integer.class); - levelControlstopCommandParams.put("optionMask", levelControlstopoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = - new CommandParameterInfo("optionOverride", Integer.class); - levelControlstopCommandParams.put( - "optionOverride", levelControlstopoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlstopInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stop( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("optionMask"), - (Integer) commandArguments.get("optionOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstopCommandParams); - levelControlClusterInteractionInfoMap.put("stop", levelControlstopInteractionInfo); - Map levelControlstopWithOnOffCommandParams = - new LinkedHashMap(); - InteractionInfo levelControlstopWithOnOffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stopWithOnOff((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstopWithOnOffCommandParams); - levelControlClusterInteractionInfoMap.put( - "stopWithOnOff", levelControlstopWithOnOffInteractionInfo); - commandMap.put("levelControl", levelControlClusterInteractionInfoMap); - Map localizationConfigurationClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("localizationConfiguration", localizationConfigurationClusterInteractionInfoMap); - Map lowPowerClusterInteractionInfoMap = new LinkedHashMap<>(); - Map lowPowersleepCommandParams = - new LinkedHashMap(); - InteractionInfo lowPowersleepInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).sleep((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - lowPowersleepCommandParams); - lowPowerClusterInteractionInfoMap.put("sleep", lowPowersleepInteractionInfo); - commandMap.put("lowPower", lowPowerClusterInteractionInfoMap); - Map mediaInputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map mediaInputhideInputStatusRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaInputhideInputStatusRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .hideInputStatusRequest((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputhideInputStatusRequestCommandParams); - mediaInputClusterInteractionInfoMap.put( - "hideInputStatusRequest", mediaInputhideInputStatusRequestInteractionInfo); - Map mediaInputrenameInputRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = - new CommandParameterInfo("index", Integer.class); - mediaInputrenameInputRequestCommandParams.put( - "index", mediaInputrenameInputRequestindexCommandParameterInfo); - - CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = - new CommandParameterInfo("name", String.class); - mediaInputrenameInputRequestCommandParams.put( - "name", mediaInputrenameInputRequestnameCommandParameterInfo); - - InteractionInfo mediaInputrenameInputRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .renameInputRequest( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("index"), - (String) commandArguments.get("name")); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputrenameInputRequestCommandParams); - mediaInputClusterInteractionInfoMap.put( - "renameInputRequest", mediaInputrenameInputRequestInteractionInfo); - Map mediaInputselectInputRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = - new CommandParameterInfo("index", Integer.class); - mediaInputselectInputRequestCommandParams.put( - "index", mediaInputselectInputRequestindexCommandParameterInfo); - - InteractionInfo mediaInputselectInputRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .selectInputRequest( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("index")); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputselectInputRequestCommandParams); - mediaInputClusterInteractionInfoMap.put( - "selectInputRequest", mediaInputselectInputRequestInteractionInfo); - Map mediaInputshowInputStatusRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaInputshowInputStatusRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .showInputStatusRequest((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputshowInputStatusRequestCommandParams); - mediaInputClusterInteractionInfoMap.put( - "showInputStatusRequest", mediaInputshowInputStatusRequestInteractionInfo); - commandMap.put("mediaInput", mediaInputClusterInteractionInfoMap); - Map mediaPlaybackClusterInteractionInfoMap = new LinkedHashMap<>(); - Map mediaPlaybackfastForwardRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackfastForwardRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .fastForwardRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackfastForwardRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "fastForwardRequest", mediaPlaybackfastForwardRequestInteractionInfo); - Map mediaPlaybacknextRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybacknextRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .nextRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybacknextRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "nextRequest", mediaPlaybacknextRequestInteractionInfo); - Map mediaPlaybackpauseRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackpauseRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .pauseRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackpauseRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "pauseRequest", mediaPlaybackpauseRequestInteractionInfo); - Map mediaPlaybackplayRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackplayRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .playRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackplayRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "playRequest", mediaPlaybackplayRequestInteractionInfo); - Map mediaPlaybackpreviousRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackpreviousRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .previousRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackpreviousRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "previousRequest", mediaPlaybackpreviousRequestInteractionInfo); - Map mediaPlaybackrewindRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackrewindRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .rewindRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackrewindRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "rewindRequest", mediaPlaybackrewindRequestInteractionInfo); - Map mediaPlaybackseekRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = - new CommandParameterInfo("position", Long.class); - mediaPlaybackseekRequestCommandParams.put( - "position", mediaPlaybackseekRequestpositionCommandParameterInfo); - - InteractionInfo mediaPlaybackseekRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .seekRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, - (Long) commandArguments.get("position")); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackseekRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "seekRequest", mediaPlaybackseekRequestInteractionInfo); - Map mediaPlaybackskipBackwardRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo - mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = - new CommandParameterInfo("deltaPositionMilliseconds", Long.class); - mediaPlaybackskipBackwardRequestCommandParams.put( - "deltaPositionMilliseconds", - mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); - - InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .skipBackwardRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, - (Long) commandArguments.get("deltaPositionMilliseconds")); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackskipBackwardRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "skipBackwardRequest", mediaPlaybackskipBackwardRequestInteractionInfo); - Map mediaPlaybackskipForwardRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo - mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = - new CommandParameterInfo("deltaPositionMilliseconds", Long.class); - mediaPlaybackskipForwardRequestCommandParams.put( - "deltaPositionMilliseconds", - mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); - - InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .skipForwardRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, - (Long) commandArguments.get("deltaPositionMilliseconds")); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackskipForwardRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "skipForwardRequest", mediaPlaybackskipForwardRequestInteractionInfo); - Map mediaPlaybackstartOverRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackstartOverRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .startOverRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackstartOverRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "startOverRequest", mediaPlaybackstartOverRequestInteractionInfo); - Map mediaPlaybackstopRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackstopRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .stopRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackstopRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "stopRequest", mediaPlaybackstopRequestInteractionInfo); - commandMap.put("mediaPlayback", mediaPlaybackClusterInteractionInfoMap); - Map modeSelectClusterInteractionInfoMap = new LinkedHashMap<>(); - Map modeSelectchangeToModeCommandParams = - new LinkedHashMap(); - CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = - new CommandParameterInfo("newMode", Integer.class); - modeSelectchangeToModeCommandParams.put( - "newMode", modeSelectchangeToModenewModeCommandParameterInfo); - - InteractionInfo modeSelectchangeToModeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .changeToMode( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("newMode")); - }, - () -> new DelegatedDefaultClusterCallback(), - modeSelectchangeToModeCommandParams); - modeSelectClusterInteractionInfoMap.put("changeToMode", modeSelectchangeToModeInteractionInfo); - commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); - Map networkCommissioningClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = - new LinkedHashMap(); - CommandParameterInfo - networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = - new CommandParameterInfo("operationalDataset", byte[].class); - networkCommissioningaddOrUpdateThreadNetworkCommandParams.put( - "operationalDataset", - networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); - - CommandParameterInfo - networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningaddOrUpdateThreadNetworkCommandParams.put( - "breadcrumb", networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .addOrUpdateThreadNetwork( - (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) - callback, - (byte[]) commandArguments.get("operationalDataset"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningaddOrUpdateThreadNetworkCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "addOrUpdateThreadNetwork", networkCommissioningaddOrUpdateThreadNetworkInteractionInfo); - Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = - new CommandParameterInfo("ssid", byte[].class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( - "ssid", networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = - new CommandParameterInfo("credentials", byte[].class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( - "credentials", networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( - "breadcrumb", networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .addOrUpdateWiFiNetwork( - (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) - callback, - (byte[]) commandArguments.get("ssid"), - (byte[]) commandArguments.get("credentials"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningaddOrUpdateWiFiNetworkCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "addOrUpdateWiFiNetwork", networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo); - Map networkCommissioningconnectNetworkCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = - new CommandParameterInfo("networkID", byte[].class); - networkCommissioningconnectNetworkCommandParams.put( - "networkID", networkCommissioningconnectNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningconnectNetworkCommandParams.put( - "breadcrumb", networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningconnectNetworkInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .connectNetwork( - (ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback) - callback, - (byte[]) commandArguments.get("networkID"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedConnectNetworkResponseCallback(), - networkCommissioningconnectNetworkCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "connectNetwork", networkCommissioningconnectNetworkInteractionInfo); - Map networkCommissioningremoveNetworkCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = - new CommandParameterInfo("networkID", byte[].class); - networkCommissioningremoveNetworkCommandParams.put( - "networkID", networkCommissioningremoveNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningremoveNetworkCommandParams.put( - "breadcrumb", networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningremoveNetworkInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .removeNetwork( - (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) - callback, - (byte[]) commandArguments.get("networkID"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningremoveNetworkCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "removeNetwork", networkCommissioningremoveNetworkInteractionInfo); - Map networkCommissioningreorderNetworkCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = - new CommandParameterInfo("networkID", byte[].class); - networkCommissioningreorderNetworkCommandParams.put( - "networkID", networkCommissioningreorderNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = - new CommandParameterInfo("networkIndex", Integer.class); - networkCommissioningreorderNetworkCommandParams.put( - "networkIndex", networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); - - CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningreorderNetworkCommandParams.put( - "breadcrumb", networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningreorderNetworkInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .reorderNetwork( - (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) - callback, - (byte[]) commandArguments.get("networkID"), - (Integer) commandArguments.get("networkIndex"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningreorderNetworkCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "reorderNetwork", networkCommissioningreorderNetworkInteractionInfo); - Map networkCommissioningscanNetworksCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = - new CommandParameterInfo("ssid", byte[].class); - networkCommissioningscanNetworksCommandParams.put( - "ssid", networkCommissioningscanNetworksssidCommandParameterInfo); - - CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningscanNetworksCommandParams.put( - "breadcrumb", networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningscanNetworksInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .scanNetworks( - (ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback) - callback, - (byte[]) commandArguments.get("ssid"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedScanNetworksResponseCallback(), - networkCommissioningscanNetworksCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "scanNetworks", networkCommissioningscanNetworksInteractionInfo); - commandMap.put("networkCommissioning", networkCommissioningClusterInteractionInfoMap); - Map otaSoftwareUpdateProviderClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo - otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = - new CommandParameterInfo("updateToken", byte[].class); - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put( - "updateToken", otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = - new CommandParameterInfo("newVersion", Long.class); - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put( - "newVersion", otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .applyUpdateRequest( - (ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback) - callback, - (byte[]) commandArguments.get("updateToken"), - (Long) commandArguments.get("newVersion")); - }, - () -> new DelegatedApplyUpdateResponseCallback(), - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put( - "applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo); - Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = - new LinkedHashMap(); - CommandParameterInfo - otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = - new CommandParameterInfo("updateToken", byte[].class); - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put( - "updateToken", otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); - - CommandParameterInfo - otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = - new CommandParameterInfo("softwareVersion", Long.class); - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put( - "softwareVersion", - otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .notifyUpdateApplied( - (DefaultClusterCallback) callback, - (byte[]) commandArguments.get("updateToken"), - (Long) commandArguments.get("softwareVersion")); - }, - () -> new DelegatedDefaultClusterCallback(), - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put( - "notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo); - Map otaSoftwareUpdateProviderqueryImageCommandParams = - new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = - new CommandParameterInfo("vendorId", Integer.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "vendorId", otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = - new CommandParameterInfo("productId", Integer.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "productId", otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = - new CommandParameterInfo("softwareVersion", Long.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "softwareVersion", otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = - new CommandParameterInfo("protocolsSupported", ArrayList.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "protocolsSupported", - otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = - new CommandParameterInfo("hardwareVersion", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "hardwareVersion", otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = - new CommandParameterInfo("location", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "location", otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); - - CommandParameterInfo - otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = - new CommandParameterInfo("requestorCanConsent", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "requestorCanConsent", - otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); - - CommandParameterInfo - otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = - new CommandParameterInfo("metadataForProvider", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "metadataForProvider", - otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .queryImage( - (ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback) - callback, - (Integer) commandArguments.get("vendorId"), - (Integer) commandArguments.get("productId"), - (Long) commandArguments.get("softwareVersion"), - (ArrayList) commandArguments.get("protocolsSupported"), - (Optional) commandArguments.get("hardwareVersion"), - (Optional) commandArguments.get("location"), - (Optional) commandArguments.get("requestorCanConsent"), - (Optional) commandArguments.get("metadataForProvider")); - }, - () -> new DelegatedQueryImageResponseCallback(), - otaSoftwareUpdateProviderqueryImageCommandParams); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put( - "queryImage", otaSoftwareUpdateProviderqueryImageInteractionInfo); - commandMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInteractionInfoMap); - Map otaSoftwareUpdateRequestorClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = - new LinkedHashMap(); - CommandParameterInfo - otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = - new CommandParameterInfo("providerNodeId", Long.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( - "providerNodeId", - otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = - new CommandParameterInfo("vendorId", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( - "vendorId", otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); - - CommandParameterInfo - otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = - new CommandParameterInfo("announcementReason", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( - "announcementReason", - otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); - - CommandParameterInfo - otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = - new CommandParameterInfo("metadataForNode", Optional.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( - "metadataForNode", - otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = - new CommandParameterInfo("endpoint", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( - "endpoint", otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .announceOtaProvider( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("providerNodeId"), - (Integer) commandArguments.get("vendorId"), - (Integer) commandArguments.get("announcementReason"), - (Optional) commandArguments.get("metadataForNode"), - (Integer) commandArguments.get("endpoint")); - }, - () -> new DelegatedDefaultClusterCallback(), - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams); - otaSoftwareUpdateRequestorClusterInteractionInfoMap.put( - "announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo); - commandMap.put( - "otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInteractionInfoMap); - Map occupancySensingClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("occupancySensing", occupancySensingClusterInteractionInfoMap); - Map onOffClusterInteractionInfoMap = new LinkedHashMap<>(); - Map onOffoffCommandParams = - new LinkedHashMap(); - InteractionInfo onOffoffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).off((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffoffCommandParams); - onOffClusterInteractionInfoMap.put("off", onOffoffInteractionInfo); - Map onOffoffWithEffectCommandParams = - new LinkedHashMap(); - CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = - new CommandParameterInfo("effectId", Integer.class); - onOffoffWithEffectCommandParams.put("effectId", onOffoffWithEffecteffectIdCommandParameterInfo); - - CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = - new CommandParameterInfo("effectVariant", Integer.class); - onOffoffWithEffectCommandParams.put( - "effectVariant", onOffoffWithEffecteffectVariantCommandParameterInfo); - - InteractionInfo onOffoffWithEffectInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .offWithEffect( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("effectId"), - (Integer) commandArguments.get("effectVariant")); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffoffWithEffectCommandParams); - onOffClusterInteractionInfoMap.put("offWithEffect", onOffoffWithEffectInteractionInfo); - Map onOffonCommandParams = - new LinkedHashMap(); - InteractionInfo onOffonInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).on((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonCommandParams); - onOffClusterInteractionInfoMap.put("on", onOffonInteractionInfo); - Map onOffonWithRecallGlobalSceneCommandParams = - new LinkedHashMap(); - InteractionInfo onOffonWithRecallGlobalSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .onWithRecallGlobalScene((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonWithRecallGlobalSceneCommandParams); - onOffClusterInteractionInfoMap.put( - "onWithRecallGlobalScene", onOffonWithRecallGlobalSceneInteractionInfo); - Map onOffonWithTimedOffCommandParams = - new LinkedHashMap(); - CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = - new CommandParameterInfo("onOffControl", Integer.class); - onOffonWithTimedOffCommandParams.put( - "onOffControl", onOffonWithTimedOffonOffControlCommandParameterInfo); - - CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = - new CommandParameterInfo("onTime", Integer.class); - onOffonWithTimedOffCommandParams.put("onTime", onOffonWithTimedOffonTimeCommandParameterInfo); - - CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = - new CommandParameterInfo("offWaitTime", Integer.class); - onOffonWithTimedOffCommandParams.put( - "offWaitTime", onOffonWithTimedOffoffWaitTimeCommandParameterInfo); - - InteractionInfo onOffonWithTimedOffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .onWithTimedOff( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("onOffControl"), - (Integer) commandArguments.get("onTime"), - (Integer) commandArguments.get("offWaitTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonWithTimedOffCommandParams); - onOffClusterInteractionInfoMap.put("onWithTimedOff", onOffonWithTimedOffInteractionInfo); - Map onOfftoggleCommandParams = - new LinkedHashMap(); - InteractionInfo onOfftoggleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).toggle((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - onOfftoggleCommandParams); - onOffClusterInteractionInfoMap.put("toggle", onOfftoggleInteractionInfo); - commandMap.put("onOff", onOffClusterInteractionInfoMap); - Map onOffSwitchConfigurationClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInteractionInfoMap); - Map operationalCredentialsClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map operationalCredentialsaddNOCCommandParams = - new LinkedHashMap(); - CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = - new CommandParameterInfo("NOCValue", byte[].class); - operationalCredentialsaddNOCCommandParams.put( - "NOCValue", operationalCredentialsaddNOCNOCValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = - new CommandParameterInfo("ICACValue", Optional.class); - operationalCredentialsaddNOCCommandParams.put( - "ICACValue", operationalCredentialsaddNOCICACValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = - new CommandParameterInfo("IPKValue", byte[].class); - operationalCredentialsaddNOCCommandParams.put( - "IPKValue", operationalCredentialsaddNOCIPKValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = - new CommandParameterInfo("caseAdminNode", Long.class); - operationalCredentialsaddNOCCommandParams.put( - "caseAdminNode", operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = - new CommandParameterInfo("adminVendorId", Integer.class); - operationalCredentialsaddNOCCommandParams.put( - "adminVendorId", operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); - - InteractionInfo operationalCredentialsaddNOCInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .addNOC( - (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, - (byte[]) commandArguments.get("NOCValue"), - (Optional) commandArguments.get("ICACValue"), - (byte[]) commandArguments.get("IPKValue"), - (Long) commandArguments.get("caseAdminNode"), - (Integer) commandArguments.get("adminVendorId")); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsaddNOCCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "addNOC", operationalCredentialsaddNOCInteractionInfo); - Map operationalCredentialsaddTrustedRootCertificateCommandParams = - new LinkedHashMap(); - CommandParameterInfo - operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = - new CommandParameterInfo("rootCertificate", byte[].class); - operationalCredentialsaddTrustedRootCertificateCommandParams.put( - "rootCertificate", - operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); - - InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .addTrustedRootCertificate( - (DefaultClusterCallback) callback, - (byte[]) commandArguments.get("rootCertificate")); - }, - () -> new DelegatedDefaultClusterCallback(), - operationalCredentialsaddTrustedRootCertificateCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "addTrustedRootCertificate", - operationalCredentialsaddTrustedRootCertificateInteractionInfo); - Map operationalCredentialsattestationRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo - operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = - new CommandParameterInfo("attestationNonce", byte[].class); - operationalCredentialsattestationRequestCommandParams.put( - "attestationNonce", - operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); - - InteractionInfo operationalCredentialsattestationRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .attestationRequest( - (ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) - callback, - (byte[]) commandArguments.get("attestationNonce")); - }, - () -> new DelegatedAttestationResponseCallback(), - operationalCredentialsattestationRequestCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "attestationRequest", operationalCredentialsattestationRequestInteractionInfo); - Map operationalCredentialscertificateChainRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo - operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = - new CommandParameterInfo("certificateType", Integer.class); - operationalCredentialscertificateChainRequestCommandParams.put( - "certificateType", - operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); - - InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .certificateChainRequest( - (ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) - callback, - (Integer) commandArguments.get("certificateType")); - }, - () -> new DelegatedCertificateChainResponseCallback(), - operationalCredentialscertificateChainRequestCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "certificateChainRequest", operationalCredentialscertificateChainRequestInteractionInfo); - Map operationalCredentialsopCSRRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = - new CommandParameterInfo("CSRNonce", byte[].class); - operationalCredentialsopCSRRequestCommandParams.put( - "CSRNonce", operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); - - InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .opCSRRequest( - (ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback, - (byte[]) commandArguments.get("CSRNonce")); - }, - () -> new DelegatedOpCSRResponseCallback(), - operationalCredentialsopCSRRequestCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "opCSRRequest", operationalCredentialsopCSRRequestInteractionInfo); - Map operationalCredentialsremoveFabricCommandParams = - new LinkedHashMap(); - CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = - new CommandParameterInfo("fabricIndex", Integer.class); - operationalCredentialsremoveFabricCommandParams.put( - "fabricIndex", operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); - - InteractionInfo operationalCredentialsremoveFabricInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .removeFabric( - (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, - (Integer) commandArguments.get("fabricIndex")); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsremoveFabricCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "removeFabric", operationalCredentialsremoveFabricInteractionInfo); - Map - operationalCredentialsremoveTrustedRootCertificateCommandParams = - new LinkedHashMap(); - CommandParameterInfo - operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = - new CommandParameterInfo("trustedRootIdentifier", byte[].class); - operationalCredentialsremoveTrustedRootCertificateCommandParams.put( - "trustedRootIdentifier", - operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); - - InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .removeTrustedRootCertificate( - (DefaultClusterCallback) callback, - (byte[]) commandArguments.get("trustedRootIdentifier")); - }, - () -> new DelegatedDefaultClusterCallback(), - operationalCredentialsremoveTrustedRootCertificateCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "removeTrustedRootCertificate", - operationalCredentialsremoveTrustedRootCertificateInteractionInfo); - Map operationalCredentialsupdateFabricLabelCommandParams = - new LinkedHashMap(); - CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = - new CommandParameterInfo("label", String.class); - operationalCredentialsupdateFabricLabelCommandParams.put( - "label", operationalCredentialsupdateFabricLabellabelCommandParameterInfo); - - InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .updateFabricLabel( - (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, - (String) commandArguments.get("label")); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsupdateFabricLabelCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "updateFabricLabel", operationalCredentialsupdateFabricLabelInteractionInfo); - Map operationalCredentialsupdateNOCCommandParams = - new LinkedHashMap(); - CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = - new CommandParameterInfo("NOCValue", byte[].class); - operationalCredentialsupdateNOCCommandParams.put( - "NOCValue", operationalCredentialsupdateNOCNOCValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = - new CommandParameterInfo("ICACValue", Optional.class); - operationalCredentialsupdateNOCCommandParams.put( - "ICACValue", operationalCredentialsupdateNOCICACValueCommandParameterInfo); - - InteractionInfo operationalCredentialsupdateNOCInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .updateNOC( - (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, - (byte[]) commandArguments.get("NOCValue"), - (Optional) commandArguments.get("ICACValue")); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsupdateNOCCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "updateNOC", operationalCredentialsupdateNOCInteractionInfo); - commandMap.put("operationalCredentials", operationalCredentialsClusterInteractionInfoMap); - Map powerSourceClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("powerSource", powerSourceClusterInteractionInfoMap); - Map powerSourceConfigurationClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInteractionInfoMap); - Map pressureMeasurementClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("pressureMeasurement", pressureMeasurementClusterInteractionInfoMap); - Map pumpConfigurationAndControlClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put( - "pumpConfigurationAndControl", pumpConfigurationAndControlClusterInteractionInfoMap); - Map relativeHumidityMeasurementClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put( - "relativeHumidityMeasurement", relativeHumidityMeasurementClusterInteractionInfoMap); - Map scenesClusterInteractionInfoMap = new LinkedHashMap<>(); - Map scenesaddSceneCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesaddSceneCommandParams.put("groupId", scenesaddScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = - new CommandParameterInfo("sceneId", Integer.class); - scenesaddSceneCommandParams.put("sceneId", scenesaddScenesceneIdCommandParameterInfo); - - CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - scenesaddSceneCommandParams.put( - "transitionTime", scenesaddScenetransitionTimeCommandParameterInfo); - - CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = - new CommandParameterInfo("sceneName", String.class); - scenesaddSceneCommandParams.put("sceneName", scenesaddScenesceneNameCommandParameterInfo); - - InteractionInfo scenesaddSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .addScene( - (ChipClusters.ScenesCluster.AddSceneResponseCallback) callback, - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("sceneId"), - (Integer) commandArguments.get("transitionTime"), - (String) commandArguments.get("sceneName"), - (ArrayList) - commandArguments.get("extensionFieldSets")); - }, - () -> new DelegatedAddSceneResponseCallback(), - scenesaddSceneCommandParams); - scenesClusterInteractionInfoMap.put("addScene", scenesaddSceneInteractionInfo); - Map scenesgetSceneMembershipCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesgetSceneMembershipCommandParams.put( - "groupId", scenesgetSceneMembershipgroupIdCommandParameterInfo); - - InteractionInfo scenesgetSceneMembershipInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .getSceneMembership( - (ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback, - (Integer) commandArguments.get("groupId")); - }, - () -> new DelegatedGetSceneMembershipResponseCallback(), - scenesgetSceneMembershipCommandParams); - scenesClusterInteractionInfoMap.put( - "getSceneMembership", scenesgetSceneMembershipInteractionInfo); - Map scenesrecallSceneCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesrecallSceneCommandParams.put("groupId", scenesrecallScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = - new CommandParameterInfo("sceneId", Integer.class); - scenesrecallSceneCommandParams.put("sceneId", scenesrecallScenesceneIdCommandParameterInfo); - - CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - scenesrecallSceneCommandParams.put( - "transitionTime", scenesrecallScenetransitionTimeCommandParameterInfo); - - InteractionInfo scenesrecallSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .recallScene( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("sceneId"), - (Integer) commandArguments.get("transitionTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - scenesrecallSceneCommandParams); - scenesClusterInteractionInfoMap.put("recallScene", scenesrecallSceneInteractionInfo); - Map scenesremoveAllScenesCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesremoveAllScenesCommandParams.put( - "groupId", scenesremoveAllScenesgroupIdCommandParameterInfo); - - InteractionInfo scenesremoveAllScenesInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .removeAllScenes( - (ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback, - (Integer) commandArguments.get("groupId")); - }, - () -> new DelegatedRemoveAllScenesResponseCallback(), - scenesremoveAllScenesCommandParams); - scenesClusterInteractionInfoMap.put("removeAllScenes", scenesremoveAllScenesInteractionInfo); - Map scenesremoveSceneCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesremoveSceneCommandParams.put("groupId", scenesremoveScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = - new CommandParameterInfo("sceneId", Integer.class); - scenesremoveSceneCommandParams.put("sceneId", scenesremoveScenesceneIdCommandParameterInfo); - - InteractionInfo scenesremoveSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .removeScene( - (ChipClusters.ScenesCluster.RemoveSceneResponseCallback) callback, - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("sceneId")); - }, - () -> new DelegatedRemoveSceneResponseCallback(), - scenesremoveSceneCommandParams); - scenesClusterInteractionInfoMap.put("removeScene", scenesremoveSceneInteractionInfo); - Map scenesstoreSceneCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesstoreSceneCommandParams.put("groupId", scenesstoreScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = - new CommandParameterInfo("sceneId", Integer.class); - scenesstoreSceneCommandParams.put("sceneId", scenesstoreScenesceneIdCommandParameterInfo); - - InteractionInfo scenesstoreSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .storeScene( - (ChipClusters.ScenesCluster.StoreSceneResponseCallback) callback, - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("sceneId")); - }, - () -> new DelegatedStoreSceneResponseCallback(), - scenesstoreSceneCommandParams); - scenesClusterInteractionInfoMap.put("storeScene", scenesstoreSceneInteractionInfo); - Map scenesviewSceneCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesviewSceneCommandParams.put("groupId", scenesviewScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = - new CommandParameterInfo("sceneId", Integer.class); - scenesviewSceneCommandParams.put("sceneId", scenesviewScenesceneIdCommandParameterInfo); - - InteractionInfo scenesviewSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .viewScene( - (ChipClusters.ScenesCluster.ViewSceneResponseCallback) callback, - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("sceneId")); - }, - () -> new DelegatedViewSceneResponseCallback(), - scenesviewSceneCommandParams); - scenesClusterInteractionInfoMap.put("viewScene", scenesviewSceneInteractionInfo); - commandMap.put("scenes", scenesClusterInteractionInfoMap); - Map softwareDiagnosticsClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map softwareDiagnosticsresetWatermarksCommandParams = - new LinkedHashMap(); - InteractionInfo softwareDiagnosticsresetWatermarksInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .resetWatermarks((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - softwareDiagnosticsresetWatermarksCommandParams); - softwareDiagnosticsClusterInteractionInfoMap.put( - "resetWatermarks", softwareDiagnosticsresetWatermarksInteractionInfo); - commandMap.put("softwareDiagnostics", softwareDiagnosticsClusterInteractionInfoMap); - Map switchClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("switch", switchClusterInteractionInfoMap); - Map targetNavigatorClusterInteractionInfoMap = new LinkedHashMap<>(); - Map targetNavigatornavigateTargetRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = - new CommandParameterInfo("target", Integer.class); - targetNavigatornavigateTargetRequestCommandParams.put( - "target", targetNavigatornavigateTargetRequesttargetCommandParameterInfo); - - CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = - new CommandParameterInfo("data", String.class); - targetNavigatornavigateTargetRequestCommandParams.put( - "data", targetNavigatornavigateTargetRequestdataCommandParameterInfo); - - InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .navigateTargetRequest( - (ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback) callback, - (Integer) commandArguments.get("target"), - (String) commandArguments.get("data")); - }, - () -> new DelegatedNavigateTargetResponseCallback(), - targetNavigatornavigateTargetRequestCommandParams); - targetNavigatorClusterInteractionInfoMap.put( - "navigateTargetRequest", targetNavigatornavigateTargetRequestInteractionInfo); - commandMap.put("targetNavigator", targetNavigatorClusterInteractionInfoMap); - Map temperatureMeasurementClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); - Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); - Map testClustersimpleStructEchoRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustersimpleStructEchoRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .simpleStructEchoRequest( - (ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback, - (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1")); - }, - () -> new DelegatedSimpleStructResponseCallback(), - testClustersimpleStructEchoRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "simpleStructEchoRequest", testClustersimpleStructEchoRequestInteractionInfo); - Map testClustertestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).test((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestCommandParams); - testClusterClusterInteractionInfoMap.put("test", testClustertestInteractionInfo); - Map testClustertestAddArgumentsCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = - new CommandParameterInfo("arg1", Integer.class); - testClustertestAddArgumentsCommandParams.put( - "arg1", testClustertestAddArgumentsarg1CommandParameterInfo); - - CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = - new CommandParameterInfo("arg2", Integer.class); - testClustertestAddArgumentsCommandParams.put( - "arg2", testClustertestAddArgumentsarg2CommandParameterInfo); - - InteractionInfo testClustertestAddArgumentsInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testAddArguments( - (ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback) callback, - (Integer) commandArguments.get("arg1"), - (Integer) commandArguments.get("arg2")); - }, - () -> new DelegatedTestAddArgumentsResponseCallback(), - testClustertestAddArgumentsCommandParams); - testClusterClusterInteractionInfoMap.put( - "testAddArguments", testClustertestAddArgumentsInteractionInfo); - Map testClustertestEmitTestEventRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", Integer.class); - testClustertestEmitTestEventRequestCommandParams.put( - "arg1", testClustertestEmitTestEventRequestarg1CommandParameterInfo); - - CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = - new CommandParameterInfo("arg2", Integer.class); - testClustertestEmitTestEventRequestCommandParams.put( - "arg2", testClustertestEmitTestEventRequestarg2CommandParameterInfo); - - CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = - new CommandParameterInfo("arg3", Boolean.class); - testClustertestEmitTestEventRequestCommandParams.put( - "arg3", testClustertestEmitTestEventRequestarg3CommandParameterInfo); - - InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testEmitTestEventRequest( - (ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback) callback, - (Integer) commandArguments.get("arg1"), - (Integer) commandArguments.get("arg2"), - (Boolean) commandArguments.get("arg3")); - }, - () -> new DelegatedTestEmitTestEventResponseCallback(), - testClustertestEmitTestEventRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testEmitTestEventRequest", testClustertestEmitTestEventRequestInteractionInfo); - Map testClustertestEnumsRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", Integer.class); - testClustertestEnumsRequestCommandParams.put( - "arg1", testClustertestEnumsRequestarg1CommandParameterInfo); - - CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = - new CommandParameterInfo("arg2", Integer.class); - testClustertestEnumsRequestCommandParams.put( - "arg2", testClustertestEnumsRequestarg2CommandParameterInfo); - - InteractionInfo testClustertestEnumsRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testEnumsRequest( - (ChipClusters.TestClusterCluster.TestEnumsResponseCallback) callback, - (Integer) commandArguments.get("arg1"), - (Integer) commandArguments.get("arg2")); - }, - () -> new DelegatedTestEnumsResponseCallback(), - testClustertestEnumsRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testEnumsRequest", testClustertestEnumsRequestInteractionInfo); - Map testClustertestListInt8UArgumentRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", ArrayList.class); - testClustertestListInt8UArgumentRequestCommandParams.put( - "arg1", testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListInt8UArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ArrayList) commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListInt8UArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestInteractionInfo); - Map testClustertestListInt8UReverseRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", ArrayList.class); - testClustertestListInt8UReverseRequestCommandParams.put( - "arg1", testClustertestListInt8UReverseRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListInt8UReverseRequest( - (ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) - callback, - (ArrayList) commandArguments.get("arg1")); - }, - () -> new DelegatedTestListInt8UReverseResponseCallback(), - testClustertestListInt8UReverseRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testListInt8UReverseRequest", testClustertestListInt8UReverseRequestInteractionInfo); - Map - testClustertestListNestedStructListArgumentRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestListNestedStructListArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListNestedStructListArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ArrayList) - commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListNestedStructListArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testListNestedStructListArgumentRequest", - testClustertestListNestedStructListArgumentRequestInteractionInfo); - Map testClustertestListStructArgumentRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListStructArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ArrayList) - commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListStructArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testListStructArgumentRequest", testClustertestListStructArgumentRequestInteractionInfo); - Map testClustertestNestedStructArgumentRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestNestedStructArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNestedStructArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ChipStructs.TestClusterClusterNestedStruct) commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestNestedStructArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testNestedStructArgumentRequest", - testClustertestNestedStructArgumentRequestInteractionInfo); - Map testClustertestNestedStructListArgumentRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestNestedStructListArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNestedStructListArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ChipStructs.TestClusterClusterNestedStructList) - commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestNestedStructListArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testNestedStructListArgumentRequest", - testClustertestNestedStructListArgumentRequestInteractionInfo); - Map testClustertestNotHandledCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestNotHandledInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNotHandled((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestNotHandledCommandParams); - testClusterClusterInteractionInfoMap.put( - "testNotHandled", testClustertestNotHandledInteractionInfo); - Map testClustertestNullableOptionalRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", Optional.class); - testClustertestNullableOptionalRequestCommandParams.put( - "arg1", testClustertestNullableOptionalRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNullableOptionalRequest( - (ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) - callback, - (Optional) commandArguments.get("arg1")); - }, - () -> new DelegatedTestNullableOptionalResponseCallback(), - testClustertestNullableOptionalRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testNullableOptionalRequest", testClustertestNullableOptionalRequestInteractionInfo); - Map testClustertestSimpleOptionalArgumentRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", Optional.class); - testClustertestSimpleOptionalArgumentRequestCommandParams.put( - "arg1", testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testSimpleOptionalArgumentRequest( - (DefaultClusterCallback) callback, - (Optional) commandArguments.get("arg1")); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestSimpleOptionalArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testSimpleOptionalArgumentRequest", - testClustertestSimpleOptionalArgumentRequestInteractionInfo); - Map testClustertestSpecificCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestSpecificInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testSpecific( - (ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback); - }, - () -> new DelegatedTestSpecificResponseCallback(), - testClustertestSpecificCommandParams); - testClusterClusterInteractionInfoMap.put( - "testSpecific", testClustertestSpecificInteractionInfo); - Map testClustertestStructArgumentRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestStructArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testStructArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestStructArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testStructArgumentRequest", testClustertestStructArgumentRequestInteractionInfo); - Map testClustertestUnknownCommandCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestUnknownCommandInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testUnknownCommand((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestUnknownCommandCommandParams); - testClusterClusterInteractionInfoMap.put( - "testUnknownCommand", testClustertestUnknownCommandInteractionInfo); - Map testClustertimedInvokeRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertimedInvokeRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .timedInvokeRequest((DefaultClusterCallback) callback, 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertimedInvokeRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "timedInvokeRequest", testClustertimedInvokeRequestInteractionInfo); - commandMap.put("testCluster", testClusterClusterInteractionInfoMap); - Map thermostatClusterInteractionInfoMap = new LinkedHashMap<>(); - Map thermostatclearWeeklyScheduleCommandParams = - new LinkedHashMap(); - InteractionInfo thermostatclearWeeklyScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .clearWeeklySchedule((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatclearWeeklyScheduleCommandParams); - thermostatClusterInteractionInfoMap.put( - "clearWeeklySchedule", thermostatclearWeeklyScheduleInteractionInfo); - Map thermostatgetRelayStatusLogCommandParams = - new LinkedHashMap(); - InteractionInfo thermostatgetRelayStatusLogInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .getRelayStatusLog( - (ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback); - }, - () -> new DelegatedGetRelayStatusLogResponseCallback(), - thermostatgetRelayStatusLogCommandParams); - thermostatClusterInteractionInfoMap.put( - "getRelayStatusLog", thermostatgetRelayStatusLogInteractionInfo); - Map thermostatgetWeeklyScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = - new CommandParameterInfo("daysToReturn", Integer.class); - thermostatgetWeeklyScheduleCommandParams.put( - "daysToReturn", thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); - - CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = - new CommandParameterInfo("modeToReturn", Integer.class); - thermostatgetWeeklyScheduleCommandParams.put( - "modeToReturn", thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); - - InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .getWeeklySchedule( - (ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback) callback, - (Integer) commandArguments.get("daysToReturn"), - (Integer) commandArguments.get("modeToReturn")); - }, - () -> new DelegatedGetWeeklyScheduleResponseCallback(), - thermostatgetWeeklyScheduleCommandParams); - thermostatClusterInteractionInfoMap.put( - "getWeeklySchedule", thermostatgetWeeklyScheduleInteractionInfo); - Map thermostatsetWeeklyScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo - thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = - new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put( - "numberOfTransitionsForSequence", - thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = - new CommandParameterInfo("dayOfWeekForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put( - "dayOfWeekForSequence", - thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = - new CommandParameterInfo("modeForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put( - "modeForSequence", thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = - new CommandParameterInfo("payload", ArrayList.class); - thermostatsetWeeklyScheduleCommandParams.put( - "payload", thermostatsetWeeklySchedulepayloadCommandParameterInfo); - - InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .setWeeklySchedule( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("numberOfTransitionsForSequence"), - (Integer) commandArguments.get("dayOfWeekForSequence"), - (Integer) commandArguments.get("modeForSequence"), - (ArrayList) commandArguments.get("payload")); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatsetWeeklyScheduleCommandParams); - thermostatClusterInteractionInfoMap.put( - "setWeeklySchedule", thermostatsetWeeklyScheduleInteractionInfo); - Map thermostatsetpointRaiseLowerCommandParams = - new LinkedHashMap(); - CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = - new CommandParameterInfo("mode", Integer.class); - thermostatsetpointRaiseLowerCommandParams.put( - "mode", thermostatsetpointRaiseLowermodeCommandParameterInfo); - - CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = - new CommandParameterInfo("amount", Integer.class); - thermostatsetpointRaiseLowerCommandParams.put( - "amount", thermostatsetpointRaiseLoweramountCommandParameterInfo); - - InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .setpointRaiseLower( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("mode"), - (Integer) commandArguments.get("amount")); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatsetpointRaiseLowerCommandParams); - thermostatClusterInteractionInfoMap.put( - "setpointRaiseLower", thermostatsetpointRaiseLowerInteractionInfo); - commandMap.put("thermostat", thermostatClusterInteractionInfoMap); - Map thermostatUserInterfaceConfigurationClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put( - "thermostatUserInterfaceConfiguration", - thermostatUserInterfaceConfigurationClusterInteractionInfoMap); - Map threadNetworkDiagnosticsClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map threadNetworkDiagnosticsresetCountsCommandParams = - new LinkedHashMap(); - InteractionInfo threadNetworkDiagnosticsresetCountsInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - threadNetworkDiagnosticsresetCountsCommandParams); - threadNetworkDiagnosticsClusterInteractionInfoMap.put( - "resetCounts", threadNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInteractionInfoMap); - Map timeFormatLocalizationClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("timeFormatLocalization", timeFormatLocalizationClusterInteractionInfoMap); - Map unitLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("unitLocalization", unitLocalizationClusterInteractionInfoMap); - Map userLabelClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("userLabel", userLabelClusterInteractionInfoMap); - Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); - Map wiFiNetworkDiagnosticsClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map wiFiNetworkDiagnosticsresetCountsCommandParams = - new LinkedHashMap(); - InteractionInfo wiFiNetworkDiagnosticsresetCountsInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - wiFiNetworkDiagnosticsresetCountsCommandParams); - wiFiNetworkDiagnosticsClusterInteractionInfoMap.put( - "resetCounts", wiFiNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInteractionInfoMap); - Map windowCoveringClusterInteractionInfoMap = new LinkedHashMap<>(); - Map windowCoveringdownOrCloseCommandParams = - new LinkedHashMap(); - InteractionInfo windowCoveringdownOrCloseInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .downOrClose((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringdownOrCloseCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "downOrClose", windowCoveringdownOrCloseInteractionInfo); - Map windowCoveringgoToLiftPercentageCommandParams = - new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = - new CommandParameterInfo("liftPercentageValue", Integer.class); - windowCoveringgoToLiftPercentageCommandParams.put( - "liftPercentageValue", - windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); - - CommandParameterInfo - windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = - new CommandParameterInfo("liftPercent100thsValue", Integer.class); - windowCoveringgoToLiftPercentageCommandParams.put( - "liftPercent100thsValue", - windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToLiftPercentage( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("liftPercentageValue"), - (Integer) commandArguments.get("liftPercent100thsValue")); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToLiftPercentageCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "goToLiftPercentage", windowCoveringgoToLiftPercentageInteractionInfo); - Map windowCoveringgoToLiftValueCommandParams = - new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = - new CommandParameterInfo("liftValue", Integer.class); - windowCoveringgoToLiftValueCommandParams.put( - "liftValue", windowCoveringgoToLiftValueliftValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToLiftValueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToLiftValue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("liftValue")); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToLiftValueCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "goToLiftValue", windowCoveringgoToLiftValueInteractionInfo); - Map windowCoveringgoToTiltPercentageCommandParams = - new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = - new CommandParameterInfo("tiltPercentageValue", Integer.class); - windowCoveringgoToTiltPercentageCommandParams.put( - "tiltPercentageValue", - windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); - - CommandParameterInfo - windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = - new CommandParameterInfo("tiltPercent100thsValue", Integer.class); - windowCoveringgoToTiltPercentageCommandParams.put( - "tiltPercent100thsValue", - windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToTiltPercentage( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("tiltPercentageValue"), - (Integer) commandArguments.get("tiltPercent100thsValue")); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToTiltPercentageCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "goToTiltPercentage", windowCoveringgoToTiltPercentageInteractionInfo); - Map windowCoveringgoToTiltValueCommandParams = - new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = - new CommandParameterInfo("tiltValue", Integer.class); - windowCoveringgoToTiltValueCommandParams.put( - "tiltValue", windowCoveringgoToTiltValuetiltValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToTiltValueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToTiltValue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("tiltValue")); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToTiltValueCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "goToTiltValue", windowCoveringgoToTiltValueInteractionInfo); - Map windowCoveringstopMotionCommandParams = - new LinkedHashMap(); - InteractionInfo windowCoveringstopMotionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .stopMotion((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringstopMotionCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "stopMotion", windowCoveringstopMotionInteractionInfo); - Map windowCoveringupOrOpenCommandParams = - new LinkedHashMap(); - InteractionInfo windowCoveringupOrOpenInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .upOrOpen((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringupOrOpenCommandParams); - windowCoveringClusterInteractionInfoMap.put("upOrOpen", windowCoveringupOrOpenInteractionInfo); - commandMap.put("windowCovering", windowCoveringClusterInteractionInfoMap); - return commandMap; - } -} diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java index 2dc210109c6a96..48ec9330a3b2f2 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java @@ -29,8466 +29,8045 @@ public class ClusterReadMapping { public Map> getReadAttributeMap() { Map> readAttributeMap = new HashMap<>(); - Map readAccessControlInteractionInfo = new LinkedHashMap<>(); - Map readAccessControlAclCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlAclAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readAclAttribute( - (ChipClusters.AccessControlCluster.AclAttributeCallback) callback); - }, + Map readAccessControlInteractionInfo = 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); - readAccessControlInteractionInfo.put( - "readAclAttribute", readAccessControlAclAttributeInteractionInfo); - Map readAccessControlExtensionCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlExtensionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readExtensionAttribute( - (ChipClusters.AccessControlCluster.ExtensionAttributeCallback) callback); - }, + readAccessControlAclCommandParams + ); + readAccessControlInteractionInfo.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); - readAccessControlInteractionInfo.put( - "readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); - Map readAccessControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AccessControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAccessControlClusterAttributeListAttributeCallback(), - readAccessControlAttributeListCommandParams); - readAccessControlInteractionInfo.put( - "readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); - Map readAccessControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlClusterRevisionCommandParams); - readAccessControlInteractionInfo.put( - "readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("accessControl", readAccessControlInteractionInfo); - Map readAccountLoginInteractionInfo = new LinkedHashMap<>(); - Map readAccountLoginAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AccountLoginCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), - readAccountLoginAttributeListCommandParams); - readAccountLoginInteractionInfo.put( - "readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); - Map readAccountLoginClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccountLoginClusterRevisionCommandParams); - readAccountLoginInteractionInfo.put( - "readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("accountLogin", readAccountLoginInteractionInfo); - Map readAdministratorCommissioningInteractionInfo = - new LinkedHashMap<>(); - Map readAdministratorCommissioningWindowStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readWindowStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningWindowStatusCommandParams); - readAdministratorCommissioningInteractionInfo.put( - "readWindowStatusAttribute", - readAdministratorCommissioningWindowStatusAttributeInteractionInfo); - Map readAdministratorCommissioningAdminFabricIndexCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readAdminFabricIndexAttribute( - (ChipClusters.AdministratorCommissioningCluster - .AdminFabricIndexAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningAdminFabricIndexCommandParams); - readAdministratorCommissioningInteractionInfo.put( - "readAdminFabricIndexAttribute", - readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); - Map readAdministratorCommissioningAdminVendorIdCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readAdminVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningAdminVendorIdCommandParams); - readAdministratorCommissioningInteractionInfo.put( - "readAdminVendorIdAttribute", - readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); - Map readAdministratorCommissioningAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AdministratorCommissioningCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), - readAdministratorCommissioningAttributeListCommandParams); - readAdministratorCommissioningInteractionInfo.put( - "readAttributeListAttribute", - readAdministratorCommissioningAttributeListAttributeInteractionInfo); - Map readAdministratorCommissioningClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningClusterRevisionCommandParams); - readAdministratorCommissioningInteractionInfo.put( - "readClusterRevisionAttribute", - readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "administratorCommissioning", readAdministratorCommissioningInteractionInfo); - Map readApplicationBasicInteractionInfo = new LinkedHashMap<>(); - Map readApplicationBasicVendorNameCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readAccessControlExtensionCommandParams + ); + readAccessControlInteractionInfo.put("readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); + Map readAccessControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readAttributeListAttribute( + ( ChipClusters.AccessControlCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccessControlClusterAttributeListAttributeCallback(), + readAccessControlAttributeListCommandParams + ); + readAccessControlInteractionInfo.put("readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); + Map readAccessControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlClusterRevisionCommandParams + ); + readAccessControlInteractionInfo.put("readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("accessControl", readAccessControlInteractionInfo); + Map readAccountLoginInteractionInfo = new LinkedHashMap<>(); + Map readAccountLoginAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster).readAttributeListAttribute( + ( ChipClusters.AccountLoginCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), + readAccountLoginAttributeListCommandParams + ); + readAccountLoginInteractionInfo.put("readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); + Map readAccountLoginClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccountLoginClusterRevisionCommandParams + ); + readAccountLoginInteractionInfo.put("readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("accountLogin", readAccountLoginInteractionInfo); + Map readAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readAdministratorCommissioningWindowStatusCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readWindowStatusAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningWindowStatusCommandParams + ); + readAdministratorCommissioningInteractionInfo.put("readWindowStatusAttribute", readAdministratorCommissioningWindowStatusAttributeInteractionInfo); + Map readAdministratorCommissioningAdminFabricIndexCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminFabricIndexAttribute( + ( ChipClusters.AdministratorCommissioningCluster.AdminFabricIndexAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningAdminFabricIndexCommandParams + ); + readAdministratorCommissioningInteractionInfo.put("readAdminFabricIndexAttribute", readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); + Map readAdministratorCommissioningAdminVendorIdCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminVendorIdAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningAdminVendorIdCommandParams + ); + readAdministratorCommissioningInteractionInfo.put("readAdminVendorIdAttribute", readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); + Map readAdministratorCommissioningAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readAttributeListAttribute( + ( ChipClusters.AdministratorCommissioningCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), + readAdministratorCommissioningAttributeListCommandParams + ); + readAdministratorCommissioningInteractionInfo.put("readAttributeListAttribute", readAdministratorCommissioningAttributeListAttributeInteractionInfo); + Map readAdministratorCommissioningClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningClusterRevisionCommandParams + ); + readAdministratorCommissioningInteractionInfo.put("readClusterRevisionAttribute", readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("administratorCommissioning", readAdministratorCommissioningInteractionInfo); + Map readApplicationBasicInteractionInfo = new LinkedHashMap<>(); + Map readApplicationBasicVendorNameCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readVendorNameAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicVendorNameCommandParams); - readApplicationBasicInteractionInfo.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); - readApplicationBasicInteractionInfo.put( - "readVendorIdAttribute", readApplicationBasicVendorIdAttributeInteractionInfo); - Map readApplicationBasicApplicationNameCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readApplicationNameAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readApplicationBasicVendorNameCommandParams + ); + readApplicationBasicInteractionInfo.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 + ); + readApplicationBasicInteractionInfo.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); - readApplicationBasicInteractionInfo.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); - readApplicationBasicInteractionInfo.put( - "readProductIdAttribute", readApplicationBasicProductIdAttributeInteractionInfo); - Map readApplicationBasicApplicationStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readApplicationStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicApplicationStatusCommandParams); - readApplicationBasicInteractionInfo.put( - "readApplicationStatusAttribute", - readApplicationBasicApplicationStatusAttributeInteractionInfo); - Map readApplicationBasicApplicationVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readApplicationVersionAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readApplicationBasicApplicationNameCommandParams + ); + readApplicationBasicInteractionInfo.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 + ); + readApplicationBasicInteractionInfo.put("readProductIdAttribute", readApplicationBasicProductIdAttributeInteractionInfo); + Map readApplicationBasicApplicationStatusCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationStatusAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicApplicationStatusCommandParams + ); + readApplicationBasicInteractionInfo.put("readApplicationStatusAttribute", readApplicationBasicApplicationStatusAttributeInteractionInfo); + Map readApplicationBasicApplicationVersionCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationVersionAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicApplicationVersionCommandParams); - readApplicationBasicInteractionInfo.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); - readApplicationBasicInteractionInfo.put( - "readAllowedVendorListAttribute", - readApplicationBasicAllowedVendorListAttributeInteractionInfo); - Map readApplicationBasicAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationBasicClusterAttributeListAttributeCallback(), - readApplicationBasicAttributeListCommandParams); - readApplicationBasicInteractionInfo.put( - "readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); - Map readApplicationBasicClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicClusterRevisionCommandParams); - readApplicationBasicInteractionInfo.put( - "readClusterRevisionAttribute", - readApplicationBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("applicationBasic", readApplicationBasicInteractionInfo); - Map readApplicationLauncherInteractionInfo = new LinkedHashMap<>(); - Map readApplicationLauncherApplicationLauncherListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherApplicationLauncherListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readApplicationLauncherListAttribute( - (ChipClusters.ApplicationLauncherCluster - .ApplicationLauncherListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback(), - readApplicationLauncherApplicationLauncherListCommandParams); - readApplicationLauncherInteractionInfo.put( - "readApplicationLauncherListAttribute", - readApplicationLauncherApplicationLauncherListAttributeInteractionInfo); - Map readApplicationLauncherAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), - readApplicationLauncherAttributeListCommandParams); - readApplicationLauncherInteractionInfo.put( - "readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); - Map readApplicationLauncherClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationLauncherClusterRevisionCommandParams); - readApplicationLauncherInteractionInfo.put( - "readClusterRevisionAttribute", - readApplicationLauncherClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("applicationLauncher", readApplicationLauncherInteractionInfo); - Map readAudioOutputInteractionInfo = new LinkedHashMap<>(); - Map readAudioOutputAudioOutputListCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputAudioOutputListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readAudioOutputListAttribute( - (ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAudioOutputClusterAudioOutputListAttributeCallback(), - readAudioOutputAudioOutputListCommandParams); - readAudioOutputInteractionInfo.put( - "readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeInteractionInfo); - Map readAudioOutputCurrentAudioOutputCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputCurrentAudioOutputAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readCurrentAudioOutputAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputCurrentAudioOutputCommandParams); - readAudioOutputInteractionInfo.put( - "readCurrentAudioOutputAttribute", - readAudioOutputCurrentAudioOutputAttributeInteractionInfo); - Map readAudioOutputAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AudioOutputCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), - readAudioOutputAttributeListCommandParams); - readAudioOutputInteractionInfo.put( - "readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); - Map readAudioOutputClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputClusterRevisionCommandParams); - readAudioOutputInteractionInfo.put( - "readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("audioOutput", readAudioOutputInteractionInfo); - Map readBarrierControlInteractionInfo = new LinkedHashMap<>(); - Map readBarrierControlBarrierMovingStateCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierMovingStateAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierMovingStateCommandParams); - readBarrierControlInteractionInfo.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); - readBarrierControlInteractionInfo.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); - readBarrierControlInteractionInfo.put( - "readBarrierCapabilitiesAttribute", - readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); - Map readBarrierControlBarrierPositionCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierPositionCommandParams); - readBarrierControlInteractionInfo.put( - "readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); - Map readBarrierControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BarrierControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBarrierControlClusterAttributeListAttributeCallback(), - readBarrierControlAttributeListCommandParams); - readBarrierControlInteractionInfo.put( - "readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); - Map readBarrierControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlClusterRevisionCommandParams); - readBarrierControlInteractionInfo.put( - "readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("barrierControl", readBarrierControlInteractionInfo); - Map readBasicInteractionInfo = new LinkedHashMap<>(); - Map readBasicInteractionModelVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInteractionModelVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readInteractionModelVersionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInteractionModelVersionCommandParams); - readBasicInteractionInfo.put( - "readInteractionModelVersionAttribute", - readBasicInteractionModelVersionAttributeInteractionInfo); - Map readBasicVendorNameCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicVendorNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readApplicationBasicApplicationVersionCommandParams + ); + readApplicationBasicInteractionInfo.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 + ); + readApplicationBasicInteractionInfo.put("readAllowedVendorListAttribute", readApplicationBasicAllowedVendorListAttributeInteractionInfo); + Map readApplicationBasicAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterAttributeListAttributeCallback(), + readApplicationBasicAttributeListCommandParams + ); + readApplicationBasicInteractionInfo.put("readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); + Map readApplicationBasicClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicClusterRevisionCommandParams + ); + readApplicationBasicInteractionInfo.put("readClusterRevisionAttribute", readApplicationBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationBasic", readApplicationBasicInteractionInfo); + Map readApplicationLauncherInteractionInfo = new LinkedHashMap<>(); + Map readApplicationLauncherApplicationLauncherListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherApplicationLauncherListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readApplicationLauncherListAttribute( + ( ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback(), + readApplicationLauncherApplicationLauncherListCommandParams + ); + readApplicationLauncherInteractionInfo.put("readApplicationLauncherListAttribute", readApplicationLauncherApplicationLauncherListAttributeInteractionInfo); + Map readApplicationLauncherAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), + readApplicationLauncherAttributeListCommandParams + ); + readApplicationLauncherInteractionInfo.put("readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); + Map readApplicationLauncherClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationLauncherClusterRevisionCommandParams + ); + readApplicationLauncherInteractionInfo.put("readClusterRevisionAttribute", readApplicationLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationLauncher", readApplicationLauncherInteractionInfo); + Map readAudioOutputInteractionInfo = new LinkedHashMap<>(); + Map readAudioOutputAudioOutputListCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputAudioOutputListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readAudioOutputListAttribute( + ( ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAudioOutputListAttributeCallback(), + readAudioOutputAudioOutputListCommandParams + ); + readAudioOutputInteractionInfo.put("readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeInteractionInfo); + Map readAudioOutputCurrentAudioOutputCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputCurrentAudioOutputAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readCurrentAudioOutputAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputCurrentAudioOutputCommandParams + ); + readAudioOutputInteractionInfo.put("readCurrentAudioOutputAttribute", readAudioOutputCurrentAudioOutputAttributeInteractionInfo); + Map readAudioOutputAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readAttributeListAttribute( + ( ChipClusters.AudioOutputCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), + readAudioOutputAttributeListCommandParams + ); + readAudioOutputInteractionInfo.put("readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); + Map readAudioOutputClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputClusterRevisionCommandParams + ); + readAudioOutputInteractionInfo.put("readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("audioOutput", readAudioOutputInteractionInfo); + Map readBarrierControlInteractionInfo = new LinkedHashMap<>(); + Map readBarrierControlBarrierMovingStateCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierMovingStateAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierMovingStateCommandParams + ); + readBarrierControlInteractionInfo.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 + ); + readBarrierControlInteractionInfo.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 + ); + readBarrierControlInteractionInfo.put("readBarrierCapabilitiesAttribute", readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); + Map readBarrierControlBarrierPositionCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierPositionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierPositionCommandParams + ); + readBarrierControlInteractionInfo.put("readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); + Map readBarrierControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BarrierControlCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBarrierControlClusterAttributeListAttributeCallback(), + readBarrierControlAttributeListCommandParams + ); + readBarrierControlInteractionInfo.put("readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); + Map readBarrierControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlClusterRevisionCommandParams + ); + readBarrierControlInteractionInfo.put("readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("barrierControl", readBarrierControlInteractionInfo); + Map readBasicInteractionInfo = new LinkedHashMap<>(); + Map readBasicInteractionModelVersionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInteractionModelVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readInteractionModelVersionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInteractionModelVersionCommandParams + ); + readBasicInteractionInfo.put("readInteractionModelVersionAttribute", readBasicInteractionModelVersionAttributeInteractionInfo); + Map readBasicVendorNameCommandParams = new LinkedHashMap(); + InteractionInfo readBasicVendorNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readVendorNameAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicVendorNameCommandParams); - readBasicInteractionInfo.put( - "readVendorNameAttribute", readBasicVendorNameAttributeInteractionInfo); - Map readBasicVendorIDCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicVendorIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readVendorIDAttribute( - (ChipClusters.BasicCluster.VendorIDAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicVendorIDCommandParams); - readBasicInteractionInfo.put( - "readVendorIDAttribute", readBasicVendorIDAttributeInteractionInfo); - Map readBasicProductNameCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicProductNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readProductNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicVendorNameCommandParams + ); + readBasicInteractionInfo.put("readVendorNameAttribute", readBasicVendorNameAttributeInteractionInfo); + Map readBasicVendorIDCommandParams = new LinkedHashMap(); + InteractionInfo readBasicVendorIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readVendorIDAttribute( + ( ChipClusters.BasicCluster.VendorIDAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicVendorIDCommandParams + ); + readBasicInteractionInfo.put("readVendorIDAttribute", readBasicVendorIDAttributeInteractionInfo); + Map readBasicProductNameCommandParams = new LinkedHashMap(); + InteractionInfo readBasicProductNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readProductNameAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductNameCommandParams); - readBasicInteractionInfo.put( - "readProductNameAttribute", readBasicProductNameAttributeInteractionInfo); - Map readBasicProductIDCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicProductIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readProductIDAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicProductIDCommandParams); - readBasicInteractionInfo.put( - "readProductIDAttribute", readBasicProductIDAttributeInteractionInfo); - Map readBasicNodeLabelCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicNodeLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readNodeLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicProductNameCommandParams + ); + readBasicInteractionInfo.put("readProductNameAttribute", readBasicProductNameAttributeInteractionInfo); + Map readBasicProductIDCommandParams = new LinkedHashMap(); + InteractionInfo readBasicProductIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readProductIDAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicProductIDCommandParams + ); + readBasicInteractionInfo.put("readProductIDAttribute", readBasicProductIDAttributeInteractionInfo); + Map readBasicNodeLabelCommandParams = new LinkedHashMap(); + InteractionInfo readBasicNodeLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readNodeLabelAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicNodeLabelCommandParams); - readBasicInteractionInfo.put( - "readNodeLabelAttribute", readBasicNodeLabelAttributeInteractionInfo); - Map readBasicLocationCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicLocationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readLocationAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicNodeLabelCommandParams + ); + readBasicInteractionInfo.put("readNodeLabelAttribute", readBasicNodeLabelAttributeInteractionInfo); + Map readBasicLocationCommandParams = new LinkedHashMap(); + InteractionInfo readBasicLocationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readLocationAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicLocationCommandParams); - readBasicInteractionInfo.put( - "readLocationAttribute", readBasicLocationAttributeInteractionInfo); - Map readBasicHardwareVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicHardwareVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readHardwareVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicHardwareVersionCommandParams); - readBasicInteractionInfo.put( - "readHardwareVersionAttribute", readBasicHardwareVersionAttributeInteractionInfo); - Map readBasicHardwareVersionStringCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicHardwareVersionStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readHardwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicLocationCommandParams + ); + readBasicInteractionInfo.put("readLocationAttribute", readBasicLocationAttributeInteractionInfo); + Map readBasicHardwareVersionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicHardwareVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readHardwareVersionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicHardwareVersionCommandParams + ); + readBasicInteractionInfo.put("readHardwareVersionAttribute", readBasicHardwareVersionAttributeInteractionInfo); + Map readBasicHardwareVersionStringCommandParams = new LinkedHashMap(); + InteractionInfo readBasicHardwareVersionStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readHardwareVersionStringAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicHardwareVersionStringCommandParams); - readBasicInteractionInfo.put( - "readHardwareVersionStringAttribute", - readBasicHardwareVersionStringAttributeInteractionInfo); - Map readBasicSoftwareVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicSoftwareVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readSoftwareVersionAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readBasicHardwareVersionStringCommandParams + ); + readBasicInteractionInfo.put("readHardwareVersionStringAttribute", readBasicHardwareVersionStringAttributeInteractionInfo); + Map readBasicSoftwareVersionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicSoftwareVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readSoftwareVersionAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBasicSoftwareVersionCommandParams); - readBasicInteractionInfo.put( - "readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeInteractionInfo); - Map readBasicSoftwareVersionStringCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicSoftwareVersionStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readSoftwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicSoftwareVersionCommandParams + ); + readBasicInteractionInfo.put("readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeInteractionInfo); + Map readBasicSoftwareVersionStringCommandParams = new LinkedHashMap(); + InteractionInfo readBasicSoftwareVersionStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readSoftwareVersionStringAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicSoftwareVersionStringCommandParams); - readBasicInteractionInfo.put( - "readSoftwareVersionStringAttribute", - readBasicSoftwareVersionStringAttributeInteractionInfo); - Map readBasicManufacturingDateCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicManufacturingDateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readManufacturingDateAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicSoftwareVersionStringCommandParams + ); + readBasicInteractionInfo.put("readSoftwareVersionStringAttribute", readBasicSoftwareVersionStringAttributeInteractionInfo); + Map readBasicManufacturingDateCommandParams = new LinkedHashMap(); + InteractionInfo readBasicManufacturingDateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readManufacturingDateAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicManufacturingDateCommandParams); - readBasicInteractionInfo.put( - "readManufacturingDateAttribute", readBasicManufacturingDateAttributeInteractionInfo); - Map readBasicPartNumberCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicPartNumberAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readPartNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicManufacturingDateCommandParams + ); + readBasicInteractionInfo.put("readManufacturingDateAttribute", readBasicManufacturingDateAttributeInteractionInfo); + Map readBasicPartNumberCommandParams = new LinkedHashMap(); + InteractionInfo readBasicPartNumberAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readPartNumberAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicPartNumberCommandParams); - readBasicInteractionInfo.put( - "readPartNumberAttribute", readBasicPartNumberAttributeInteractionInfo); - Map readBasicProductURLCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicProductURLAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readProductURLAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicPartNumberCommandParams + ); + readBasicInteractionInfo.put("readPartNumberAttribute", readBasicPartNumberAttributeInteractionInfo); + Map readBasicProductURLCommandParams = new LinkedHashMap(); + InteractionInfo readBasicProductURLAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readProductURLAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductURLCommandParams); - readBasicInteractionInfo.put( - "readProductURLAttribute", readBasicProductURLAttributeInteractionInfo); - Map readBasicProductLabelCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicProductLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readProductLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicProductURLCommandParams + ); + readBasicInteractionInfo.put("readProductURLAttribute", readBasicProductURLAttributeInteractionInfo); + Map readBasicProductLabelCommandParams = new LinkedHashMap(); + InteractionInfo readBasicProductLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readProductLabelAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductLabelCommandParams); - readBasicInteractionInfo.put( - "readProductLabelAttribute", readBasicProductLabelAttributeInteractionInfo); - Map readBasicSerialNumberCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicSerialNumberAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readSerialNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicProductLabelCommandParams + ); + readBasicInteractionInfo.put("readProductLabelAttribute", readBasicProductLabelAttributeInteractionInfo); + Map readBasicSerialNumberCommandParams = new LinkedHashMap(); + InteractionInfo readBasicSerialNumberAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readSerialNumberAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicSerialNumberCommandParams); - readBasicInteractionInfo.put( - "readSerialNumberAttribute", readBasicSerialNumberAttributeInteractionInfo); - Map readBasicLocalConfigDisabledCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicLocalConfigDisabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readLocalConfigDisabledAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readBasicSerialNumberCommandParams + ); + readBasicInteractionInfo.put("readSerialNumberAttribute", readBasicSerialNumberAttributeInteractionInfo); + Map readBasicLocalConfigDisabledCommandParams = new LinkedHashMap(); + InteractionInfo readBasicLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readLocalConfigDisabledAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicLocalConfigDisabledCommandParams); - readBasicInteractionInfo.put( - "readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeInteractionInfo); - Map readBasicReachableCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicReachableAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readReachableAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readBasicLocalConfigDisabledCommandParams + ); + readBasicInteractionInfo.put("readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeInteractionInfo); + Map readBasicReachableCommandParams = new LinkedHashMap(); + InteractionInfo readBasicReachableAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readReachableAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicReachableCommandParams); - readBasicInteractionInfo.put( - "readReachableAttribute", readBasicReachableAttributeInteractionInfo); - Map readBasicUniqueIDCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicUniqueIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readUniqueIDAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicReachableCommandParams + ); + readBasicInteractionInfo.put("readReachableAttribute", readBasicReachableAttributeInteractionInfo); + Map readBasicUniqueIDCommandParams = new LinkedHashMap(); + InteractionInfo readBasicUniqueIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readUniqueIDAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicUniqueIDCommandParams); - readBasicInteractionInfo.put( - "readUniqueIDAttribute", readBasicUniqueIDAttributeInteractionInfo); - Map readBasicAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BasicCluster.AttributeListAttributeCallback) callback); - }, + readBasicUniqueIDCommandParams + ); + readBasicInteractionInfo.put("readUniqueIDAttribute", readBasicUniqueIDAttributeInteractionInfo); + Map readBasicAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBasicAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BasicCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBasicClusterAttributeListAttributeCallback(), - readBasicAttributeListCommandParams); - readBasicInteractionInfo.put( - "readAttributeListAttribute", readBasicAttributeListAttributeInteractionInfo); - Map readBasicClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicClusterRevisionCommandParams); - readBasicInteractionInfo.put( - "readClusterRevisionAttribute", readBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("basic", readBasicInteractionInfo); - Map readBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map readBinaryInputBasicOutOfServiceCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readOutOfServiceAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readBasicAttributeListCommandParams + ); + readBasicInteractionInfo.put("readAttributeListAttribute", readBasicAttributeListAttributeInteractionInfo); + Map readBasicClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicClusterRevisionCommandParams + ); + readBasicInteractionInfo.put("readClusterRevisionAttribute", readBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("basic", readBasicInteractionInfo); + Map readBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); + Map readBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readOutOfServiceAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicOutOfServiceCommandParams); - readBinaryInputBasicInteractionInfo.put( - "readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); - Map readBinaryInputBasicPresentValueCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readPresentValueAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readBinaryInputBasicOutOfServiceCommandParams + ); + readBinaryInputBasicInteractionInfo.put("readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); + Map readBinaryInputBasicPresentValueCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readPresentValueAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicPresentValueCommandParams); - readBinaryInputBasicInteractionInfo.put( - "readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); - Map readBinaryInputBasicStatusFlagsCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readStatusFlagsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicStatusFlagsCommandParams); - readBinaryInputBasicInteractionInfo.put( - "readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); - Map readBinaryInputBasicAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), - readBinaryInputBasicAttributeListCommandParams); - readBinaryInputBasicInteractionInfo.put( - "readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); - Map readBinaryInputBasicClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicClusterRevisionCommandParams); - readBinaryInputBasicInteractionInfo.put( - "readClusterRevisionAttribute", - readBinaryInputBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("binaryInputBasic", readBinaryInputBasicInteractionInfo); - Map readBindingInteractionInfo = new LinkedHashMap<>(); - Map readBindingAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBindingAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BindingCluster.AttributeListAttributeCallback) callback); - }, + readBinaryInputBasicPresentValueCommandParams + ); + readBinaryInputBasicInteractionInfo.put("readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); + Map readBinaryInputBasicStatusFlagsCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readStatusFlagsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicStatusFlagsCommandParams + ); + readBinaryInputBasicInteractionInfo.put("readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); + Map readBinaryInputBasicAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), + readBinaryInputBasicAttributeListCommandParams + ); + readBinaryInputBasicInteractionInfo.put("readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); + Map readBinaryInputBasicClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicClusterRevisionCommandParams + ); + readBinaryInputBasicInteractionInfo.put("readClusterRevisionAttribute", readBinaryInputBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binaryInputBasic", readBinaryInputBasicInteractionInfo); + Map readBindingInteractionInfo = new LinkedHashMap<>(); + Map readBindingAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBindingAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BindingCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBindingClusterAttributeListAttributeCallback(), - readBindingAttributeListCommandParams); - readBindingInteractionInfo.put( - "readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); - Map readBindingClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBindingClusterRevisionCommandParams); - readBindingInteractionInfo.put( - "readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("binding", readBindingInteractionInfo); - Map readBooleanStateInteractionInfo = new LinkedHashMap<>(); - Map readBooleanStateStateValueCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readStateValueAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readBindingAttributeListCommandParams + ); + readBindingInteractionInfo.put("readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); + Map readBindingClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBindingClusterRevisionCommandParams + ); + readBindingInteractionInfo.put("readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binding", readBindingInteractionInfo); + Map readBooleanStateInteractionInfo = new LinkedHashMap<>(); + Map readBooleanStateStateValueCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readStateValueAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBooleanStateStateValueCommandParams); - readBooleanStateInteractionInfo.put( - "readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); - Map readBooleanStateAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BooleanStateCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), - readBooleanStateAttributeListCommandParams); - readBooleanStateInteractionInfo.put( - "readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); - Map readBooleanStateClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBooleanStateClusterRevisionCommandParams); - readBooleanStateInteractionInfo.put( - "readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("booleanState", readBooleanStateInteractionInfo); - Map readBridgedActionsInteractionInfo = new LinkedHashMap<>(); - Map readBridgedActionsActionListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedActionsActionListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .readActionListAttribute( - (ChipClusters.BridgedActionsCluster.ActionListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedBridgedActionsClusterActionListAttributeCallback(), - readBridgedActionsActionListCommandParams); - readBridgedActionsInteractionInfo.put( - "readActionListAttribute", readBridgedActionsActionListAttributeInteractionInfo); - Map readBridgedActionsEndpointListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedActionsEndpointListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .readEndpointListAttribute( - (ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBridgedActionsClusterEndpointListAttributeCallback(), - readBridgedActionsEndpointListCommandParams); - readBridgedActionsInteractionInfo.put( - "readEndpointListAttribute", readBridgedActionsEndpointListAttributeInteractionInfo); - Map readBridgedActionsSetupUrlCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedActionsSetupUrlAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .readSetupUrlAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBooleanStateStateValueCommandParams + ); + readBooleanStateInteractionInfo.put("readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); + Map readBooleanStateAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BooleanStateCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), + readBooleanStateAttributeListCommandParams + ); + readBooleanStateInteractionInfo.put("readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); + Map readBooleanStateClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanStateClusterRevisionCommandParams + ); + readBooleanStateInteractionInfo.put("readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("booleanState", readBooleanStateInteractionInfo); + Map readBridgedActionsInteractionInfo = new LinkedHashMap<>(); + Map readBridgedActionsActionListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedActionsActionListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster).readActionListAttribute( + ( ChipClusters.BridgedActionsCluster.ActionListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterActionListAttributeCallback(), + readBridgedActionsActionListCommandParams + ); + readBridgedActionsInteractionInfo.put("readActionListAttribute", readBridgedActionsActionListAttributeInteractionInfo); + Map readBridgedActionsEndpointListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedActionsEndpointListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster).readEndpointListAttribute( + ( ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterEndpointListAttributeCallback(), + readBridgedActionsEndpointListCommandParams + ); + readBridgedActionsInteractionInfo.put("readEndpointListAttribute", readBridgedActionsEndpointListAttributeInteractionInfo); + Map readBridgedActionsSetupUrlCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedActionsSetupUrlAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster).readSetupUrlAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedActionsSetupUrlCommandParams); - readBridgedActionsInteractionInfo.put( - "readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeInteractionInfo); - Map readBridgedActionsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedActionsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BridgedActionsCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBridgedActionsClusterAttributeListAttributeCallback(), - readBridgedActionsAttributeListCommandParams); - readBridgedActionsInteractionInfo.put( - "readAttributeListAttribute", readBridgedActionsAttributeListAttributeInteractionInfo); - Map readBridgedActionsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedActionsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedActionsClusterRevisionCommandParams); - readBridgedActionsInteractionInfo.put( - "readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("bridgedActions", readBridgedActionsInteractionInfo); - Map readBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); - Map readBridgedDeviceBasicAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BridgedDeviceBasicCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback(), - readBridgedDeviceBasicAttributeListCommandParams); - readBridgedDeviceBasicInteractionInfo.put( - "readAttributeListAttribute", readBridgedDeviceBasicAttributeListAttributeInteractionInfo); - Map readBridgedDeviceBasicClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedDeviceBasicClusterRevisionCommandParams); - readBridgedDeviceBasicInteractionInfo.put( - "readClusterRevisionAttribute", - readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("bridgedDeviceBasic", readBridgedDeviceBasicInteractionInfo); - Map readChannelInteractionInfo = new LinkedHashMap<>(); - Map readChannelChannelListCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelChannelListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readChannelListAttribute( - (ChipClusters.ChannelCluster.ChannelListAttributeCallback) callback); - }, + readBridgedActionsSetupUrlCommandParams + ); + readBridgedActionsInteractionInfo.put("readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeInteractionInfo); + Map readBridgedActionsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedActionsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BridgedActionsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterAttributeListAttributeCallback(), + readBridgedActionsAttributeListCommandParams + ); + readBridgedActionsInteractionInfo.put("readAttributeListAttribute", readBridgedActionsAttributeListAttributeInteractionInfo); + Map readBridgedActionsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedActionsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedActionsClusterRevisionCommandParams + ); + readBridgedActionsInteractionInfo.put("readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedActions", readBridgedActionsInteractionInfo); + Map readBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); + Map readBridgedDeviceBasicAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BridgedDeviceBasicCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback(), + readBridgedDeviceBasicAttributeListCommandParams + ); + readBridgedDeviceBasicInteractionInfo.put("readAttributeListAttribute", readBridgedDeviceBasicAttributeListAttributeInteractionInfo); + Map readBridgedDeviceBasicClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedDeviceBasicClusterRevisionCommandParams + ); + readBridgedDeviceBasicInteractionInfo.put("readClusterRevisionAttribute", readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedDeviceBasic", readBridgedDeviceBasicInteractionInfo); + Map readChannelInteractionInfo = 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); - readChannelInteractionInfo.put( - "readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); - Map readChannelAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ChannelCluster.AttributeListAttributeCallback) callback); - }, + readChannelChannelListCommandParams + ); + readChannelInteractionInfo.put("readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); + Map readChannelAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readChannelAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ChannelCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedChannelClusterAttributeListAttributeCallback(), - readChannelAttributeListCommandParams); - readChannelInteractionInfo.put( - "readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); - Map readChannelClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readChannelClusterRevisionCommandParams); - readChannelInteractionInfo.put( - "readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("channel", readChannelInteractionInfo); - Map readColorControlInteractionInfo = new LinkedHashMap<>(); - Map readColorControlCurrentHueCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCurrentHueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentHueCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readDriftCompensationAttribute", - readColorControlDriftCompensationAttributeInteractionInfo); - Map readColorControlCompensationTextCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCompensationTextAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCompensationTextAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readChannelAttributeListCommandParams + ); + readChannelInteractionInfo.put("readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); + Map readChannelClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChannelClusterRevisionCommandParams + ); + readChannelInteractionInfo.put("readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("channel", readChannelInteractionInfo); + Map readColorControlInteractionInfo = new LinkedHashMap<>(); + Map readColorControlCurrentHueCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readCurrentHueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentHueCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); - Map readColorControlColorTemperatureCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorTemperatureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTemperatureCommandParams); - readColorControlInteractionInfo.put( - "readColorTemperatureAttribute", readColorControlColorTemperatureAttributeInteractionInfo); - Map readColorControlColorModeCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorModeCommandParams); - readColorControlInteractionInfo.put( - "readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); - Map readColorControlColorControlOptionsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorControlOptionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorControlOptionsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorControlOptionsCommandParams); - readColorControlInteractionInfo.put( - "readColorControlOptionsAttribute", - readColorControlColorControlOptionsAttributeInteractionInfo); - Map readColorControlNumberOfPrimariesCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readNumberOfPrimariesAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlNumberOfPrimariesCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); - Map readColorControlPrimary1IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary1IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary1IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); - Map readColorControlPrimary2IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary2IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary2IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); - Map readColorControlPrimary3IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary3IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary3IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); - Map readColorControlPrimary4IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary4IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary4IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); - Map readColorControlPrimary5IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary5IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary5IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); - Map readColorControlPrimary6IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary6IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary6IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); - Map readColorControlColorPointRIntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointRIntensityAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointRIntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); - Map readColorControlColorPointGIntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointGIntensityAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointGIntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); - Map readColorControlColorPointBIntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointBIntensityAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointBIntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readColorCapabilitiesAttribute", - readColorControlColorCapabilitiesAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMinCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMinAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorTempPhysicalMinAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMinCommandParams); - readColorControlInteractionInfo.put( - "readColorTempPhysicalMinAttribute", - readColorControlColorTempPhysicalMinAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorTempPhysicalMaxAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMaxCommandParams); - readColorControlInteractionInfo.put( - "readColorTempPhysicalMaxAttribute", - readColorControlColorTempPhysicalMaxAttributeInteractionInfo); - Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCoupleColorTempToLevelMinMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCoupleColorTempToLevelMinMiredsCommandParams); - readColorControlInteractionInfo.put( - "readCoupleColorTempToLevelMinMiredsAttribute", - readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); - Map readColorControlStartUpColorTemperatureMiredsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readStartUpColorTemperatureMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlStartUpColorTemperatureMiredsCommandParams); - readColorControlInteractionInfo.put( - "readStartUpColorTemperatureMiredsAttribute", - readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); - Map readColorControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ColorControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), - readColorControlAttributeListCommandParams); - readColorControlInteractionInfo.put( - "readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); - Map readColorControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlClusterRevisionCommandParams); - readColorControlInteractionInfo.put( - "readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("colorControl", readColorControlInteractionInfo); - Map readContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map readContentLauncherAcceptHeaderListCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherAcceptHeaderListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readAcceptHeaderListAttribute( - (ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback(), - readContentLauncherAcceptHeaderListCommandParams); - readContentLauncherInteractionInfo.put( - "readAcceptHeaderListAttribute", - readContentLauncherAcceptHeaderListAttributeInteractionInfo); - Map readContentLauncherSupportedStreamingProtocolsCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readSupportedStreamingProtocolsAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readColorControlCompensationTextCommandParams + ); + readColorControlInteractionInfo.put("readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); + Map readColorControlColorTemperatureCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorTemperatureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorTemperatureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTemperatureCommandParams + ); + readColorControlInteractionInfo.put("readColorTemperatureAttribute", readColorControlColorTemperatureAttributeInteractionInfo); + Map readColorControlColorModeCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorModeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorModeCommandParams + ); + readColorControlInteractionInfo.put("readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); + Map readColorControlColorControlOptionsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorControlOptionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorControlOptionsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorControlOptionsCommandParams + ); + readColorControlInteractionInfo.put("readColorControlOptionsAttribute", readColorControlColorControlOptionsAttributeInteractionInfo); + Map readColorControlNumberOfPrimariesCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readNumberOfPrimariesAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlNumberOfPrimariesCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); + Map readColorControlPrimary1IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary1IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary1IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); + Map readColorControlPrimary2IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary2IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary2IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); + Map readColorControlPrimary3IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary3IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary3IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); + Map readColorControlPrimary4IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary4IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary4IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); + Map readColorControlPrimary5IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary5IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary5IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); + Map readColorControlPrimary6IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary6IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary6IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); + Map readColorControlColorPointRIntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointRIntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointRIntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); + Map readColorControlColorPointGIntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointGIntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointGIntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); + Map readColorControlColorPointBIntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointBIntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointBIntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readColorCapabilitiesAttribute", readColorControlColorCapabilitiesAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMinCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMinAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMinAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMinCommandParams + ); + readColorControlInteractionInfo.put("readColorTempPhysicalMinAttribute", readColorControlColorTempPhysicalMinAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMaxCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMaxAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMaxCommandParams + ); + readColorControlInteractionInfo.put("readColorTempPhysicalMaxAttribute", readColorControlColorTempPhysicalMaxAttributeInteractionInfo); + Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readCoupleColorTempToLevelMinMiredsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCoupleColorTempToLevelMinMiredsCommandParams + ); + readColorControlInteractionInfo.put("readCoupleColorTempToLevelMinMiredsAttribute", readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); + Map readColorControlStartUpColorTemperatureMiredsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readStartUpColorTemperatureMiredsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlStartUpColorTemperatureMiredsCommandParams + ); + readColorControlInteractionInfo.put("readStartUpColorTemperatureMiredsAttribute", readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); + Map readColorControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ColorControlCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), + readColorControlAttributeListCommandParams + ); + readColorControlInteractionInfo.put("readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); + Map readColorControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlClusterRevisionCommandParams + ); + readColorControlInteractionInfo.put("readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("colorControl", readColorControlInteractionInfo); + Map readContentLauncherInteractionInfo = new LinkedHashMap<>(); + Map readContentLauncherAcceptHeaderListCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherAcceptHeaderListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readAcceptHeaderListAttribute( + ( ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback(), + readContentLauncherAcceptHeaderListCommandParams + ); + readContentLauncherInteractionInfo.put("readAcceptHeaderListAttribute", readContentLauncherAcceptHeaderListAttributeInteractionInfo); + Map readContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readSupportedStreamingProtocolsAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readContentLauncherSupportedStreamingProtocolsCommandParams); - readContentLauncherInteractionInfo.put( - "readSupportedStreamingProtocolsAttribute", - readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); - Map readContentLauncherAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedContentLauncherClusterAttributeListAttributeCallback(), - readContentLauncherAttributeListCommandParams); - readContentLauncherInteractionInfo.put( - "readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); - Map readContentLauncherClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readContentLauncherClusterRevisionCommandParams); - readContentLauncherInteractionInfo.put( - "readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("contentLauncher", readContentLauncherInteractionInfo); - Map readDescriptorInteractionInfo = new LinkedHashMap<>(); - Map readDescriptorDeviceListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorDeviceListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readDeviceListAttribute( - (ChipClusters.DescriptorCluster.DeviceListAttributeCallback) callback); - }, + readContentLauncherSupportedStreamingProtocolsCommandParams + ); + readContentLauncherInteractionInfo.put("readSupportedStreamingProtocolsAttribute", readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); + Map readContentLauncherAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAttributeListAttributeCallback(), + readContentLauncherAttributeListCommandParams + ); + readContentLauncherInteractionInfo.put("readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); + Map readContentLauncherClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readContentLauncherClusterRevisionCommandParams + ); + readContentLauncherInteractionInfo.put("readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("contentLauncher", readContentLauncherInteractionInfo); + Map readDescriptorInteractionInfo = new LinkedHashMap<>(); + Map readDescriptorDeviceListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorDeviceListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readDeviceListAttribute( + ( ChipClusters.DescriptorCluster.DeviceListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterDeviceListAttributeCallback(), - readDescriptorDeviceListCommandParams); - readDescriptorInteractionInfo.put( - "readDeviceListAttribute", readDescriptorDeviceListAttributeInteractionInfo); - Map readDescriptorServerListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorServerListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readServerListAttribute( - (ChipClusters.DescriptorCluster.ServerListAttributeCallback) callback); - }, + readDescriptorDeviceListCommandParams + ); + readDescriptorInteractionInfo.put("readDeviceListAttribute", readDescriptorDeviceListAttributeInteractionInfo); + Map readDescriptorServerListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorServerListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readServerListAttribute( + ( ChipClusters.DescriptorCluster.ServerListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterServerListAttributeCallback(), - readDescriptorServerListCommandParams); - readDescriptorInteractionInfo.put( - "readServerListAttribute", readDescriptorServerListAttributeInteractionInfo); - Map readDescriptorClientListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorClientListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readClientListAttribute( - (ChipClusters.DescriptorCluster.ClientListAttributeCallback) callback); - }, + readDescriptorServerListCommandParams + ); + readDescriptorInteractionInfo.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); - readDescriptorInteractionInfo.put( - "readClientListAttribute", readDescriptorClientListAttributeInteractionInfo); - Map readDescriptorPartsListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorPartsListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readPartsListAttribute( - (ChipClusters.DescriptorCluster.PartsListAttributeCallback) callback); - }, + readDescriptorClientListCommandParams + ); + readDescriptorInteractionInfo.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); - readDescriptorInteractionInfo.put( - "readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); - Map readDescriptorAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.DescriptorCluster.AttributeListAttributeCallback) callback); - }, + readDescriptorPartsListCommandParams + ); + readDescriptorInteractionInfo.put("readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); + Map readDescriptorAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readAttributeListAttribute( + ( ChipClusters.DescriptorCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterAttributeListAttributeCallback(), - readDescriptorAttributeListCommandParams); - readDescriptorInteractionInfo.put( - "readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); - Map readDescriptorClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDescriptorClusterRevisionCommandParams); - readDescriptorInteractionInfo.put( - "readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("descriptor", readDescriptorInteractionInfo); - Map readDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); - Map readDiagnosticLogsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), - readDiagnosticLogsAttributeListCommandParams); - readDiagnosticLogsInteractionInfo.put( - "readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); - readAttributeMap.put("diagnosticLogs", readDiagnosticLogsInteractionInfo); - Map readDoorLockInteractionInfo = new LinkedHashMap<>(); - Map readDoorLockLockStateCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockLockStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readLockStateAttribute( - (ChipClusters.DoorLockCluster.LockStateAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockLockStateCommandParams); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.put( - "readLockTypeAttribute", readDoorLockLockTypeAttributeInteractionInfo); - Map readDoorLockActuatorEnabledCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockActuatorEnabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readActuatorEnabledAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readDescriptorAttributeListCommandParams + ); + readDescriptorInteractionInfo.put("readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); + Map readDescriptorClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDescriptorClusterRevisionCommandParams + ); + readDescriptorInteractionInfo.put("readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("descriptor", readDescriptorInteractionInfo); + Map readDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); + Map readDiagnosticLogsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), + readDiagnosticLogsAttributeListCommandParams + ); + readDiagnosticLogsInteractionInfo.put("readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); + readAttributeMap.put("diagnosticLogs", readDiagnosticLogsInteractionInfo); + Map readDoorLockInteractionInfo = new LinkedHashMap<>(); + Map readDoorLockLockStateCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockLockStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readLockStateAttribute( + ( ChipClusters.DoorLockCluster.LockStateAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockLockStateCommandParams + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.put( - "readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); - Map readDoorLockDoorStateCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readDoorStateAttribute( - (ChipClusters.DoorLockCluster.DoorStateAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockDoorStateCommandParams); - readDoorLockInteractionInfo.put( - "readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); - Map readDoorLockNumberOfTotalUsersSupportedCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readNumberOfTotalUsersSupportedAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfTotalUsersSupportedCommandParams); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.put( - "readNumberOfYearDaySchedulesSupportedPerUserAttribute", - readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); - Map readDoorLockMaxPINCodeLengthCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readMaxPINCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMaxPINCodeLengthCommandParams); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.put( - "readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); - Map readDoorLockLanguageCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockLanguageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readLanguageAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readDoorLockActuatorEnabledCommandParams + ); + readDoorLockInteractionInfo.put("readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); + Map readDoorLockDoorStateCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readDoorStateAttribute( + ( ChipClusters.DoorLockCluster.DoorStateAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockDoorStateCommandParams + ); + readDoorLockInteractionInfo.put("readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); + Map readDoorLockNumberOfTotalUsersSupportedCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readNumberOfTotalUsersSupportedAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfTotalUsersSupportedCommandParams + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.put("readNumberOfYearDaySchedulesSupportedPerUserAttribute", readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); + Map readDoorLockMaxPINCodeLengthCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readMaxPINCodeLengthAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMaxPINCodeLengthCommandParams + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.put("readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); + Map readDoorLockLanguageCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockLanguageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readLanguageAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readDoorLockLanguageCommandParams); - readDoorLockInteractionInfo.put( - "readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); - Map readDoorLockAutoRelockTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readAutoRelockTimeAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readDoorLockLanguageCommandParams + ); + readDoorLockInteractionInfo.put("readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); + Map readDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readAutoRelockTimeAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockAutoRelockTimeCommandParams); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.put( - "readSupportedOperatingModesAttribute", - readDoorLockSupportedOperatingModesAttributeInteractionInfo); - Map readDoorLockEnableOneTouchLockingCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readEnableOneTouchLockingAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readDoorLockAutoRelockTimeCommandParams + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.put("readSupportedOperatingModesAttribute", readDoorLockSupportedOperatingModesAttributeInteractionInfo); + Map readDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readEnableOneTouchLockingAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnableOneTouchLockingCommandParams); - readDoorLockInteractionInfo.put( - "readEnableOneTouchLockingAttribute", - readDoorLockEnableOneTouchLockingAttributeInteractionInfo); - Map readDoorLockEnablePrivacyModeButtonCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readEnablePrivacyModeButtonAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readDoorLockEnableOneTouchLockingCommandParams + ); + readDoorLockInteractionInfo.put("readEnableOneTouchLockingAttribute", readDoorLockEnableOneTouchLockingAttributeInteractionInfo); + Map readDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readEnablePrivacyModeButtonAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnablePrivacyModeButtonCommandParams); - readDoorLockInteractionInfo.put( - "readEnablePrivacyModeButtonAttribute", - readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); - Map readDoorLockWrongCodeEntryLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readWrongCodeEntryLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockWrongCodeEntryLimitCommandParams); - readDoorLockInteractionInfo.put( - "readWrongCodeEntryLimitAttribute", - readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); - Map readDoorLockAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.DoorLockCluster.AttributeListAttributeCallback) callback); - }, + readDoorLockEnablePrivacyModeButtonCommandParams + ); + readDoorLockInteractionInfo.put("readEnablePrivacyModeButtonAttribute", readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); + Map readDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readWrongCodeEntryLimitAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockWrongCodeEntryLimitCommandParams + ); + readDoorLockInteractionInfo.put("readWrongCodeEntryLimitAttribute", readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); + Map readDoorLockAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readAttributeListAttribute( + ( ChipClusters.DoorLockCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDoorLockClusterAttributeListAttributeCallback(), - readDoorLockAttributeListCommandParams); - readDoorLockInteractionInfo.put( - "readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); - Map readDoorLockClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockClusterRevisionCommandParams); - readDoorLockInteractionInfo.put( - "readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("doorLock", readDoorLockInteractionInfo); - Map readElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readElectricalMeasurementMeasurementTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasurementTypeAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readDoorLockAttributeListCommandParams + ); + readDoorLockInteractionInfo.put("readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); + Map readDoorLockClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockClusterRevisionCommandParams + ); + readDoorLockInteractionInfo.put("readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("doorLock", readDoorLockInteractionInfo); + Map readElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readElectricalMeasurementMeasurementTypeCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasurementTypeAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementMeasurementTypeCommandParams); - readElectricalMeasurementInteractionInfo.put( - "readMeasurementTypeAttribute", - readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); - Map readElectricalMeasurementTotalActivePowerCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readTotalActivePowerAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readElectricalMeasurementMeasurementTypeCommandParams + ); + readElectricalMeasurementInteractionInfo.put("readMeasurementTypeAttribute", readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); + Map readElectricalMeasurementTotalActivePowerCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readTotalActivePowerAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementTotalActivePowerCommandParams); - readElectricalMeasurementInteractionInfo.put( - "readTotalActivePowerAttribute", - readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageCommandParams); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.put( - "readActivePowerMaxAttribute", - readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); - Map readElectricalMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), - readElectricalMeasurementAttributeListCommandParams); - readElectricalMeasurementInteractionInfo.put( - "readAttributeListAttribute", - readElectricalMeasurementAttributeListAttributeInteractionInfo); - Map readElectricalMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementClusterRevisionCommandParams); - readElectricalMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", - readElectricalMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("electricalMeasurement", readElectricalMeasurementInteractionInfo); - Map readEthernetNetworkDiagnosticsInteractionInfo = - new LinkedHashMap<>(); - Map readEthernetNetworkDiagnosticsPHYRateCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readPHYRateAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readEthernetNetworkDiagnosticsPHYRateCommandParams); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readFullDuplexAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readElectricalMeasurementTotalActivePowerCommandParams + ); + readElectricalMeasurementInteractionInfo.put("readTotalActivePowerAttribute", readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageCommandParams + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.put("readActivePowerMaxAttribute", readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); + Map readElectricalMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), + readElectricalMeasurementAttributeListCommandParams + ); + readElectricalMeasurementInteractionInfo.put("readAttributeListAttribute", readElectricalMeasurementAttributeListAttributeInteractionInfo); + Map readElectricalMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementClusterRevisionCommandParams + ); + readElectricalMeasurementInteractionInfo.put("readClusterRevisionAttribute", readElectricalMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("electricalMeasurement", readElectricalMeasurementInteractionInfo); + Map readEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + Map readEthernetNetworkDiagnosticsPHYRateCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPHYRateAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthernetNetworkDiagnosticsPHYRateCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.put("readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFullDuplexAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readEthernetNetworkDiagnosticsFullDuplexCommandParams); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readFullDuplexAttribute", - readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readPacketRxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsFullDuplexCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readPacketRxCountAttribute", - readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketTxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readPacketTxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsPacketRxCountCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readPacketTxCountAttribute", - readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTxErrCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readTxErrCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsPacketTxCountCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readTxErrCountAttribute", - readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCollisionCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readCollisionCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsTxErrCountCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readCollisionCountAttribute", - readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsOverrunCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsCollisionCountCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readOverrunCountAttribute", - readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readCarrierDetectAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsOverrunCountCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCarrierDetectAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readEthernetNetworkDiagnosticsCarrierDetectCommandParams); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readCarrierDetectAttribute", - readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTimeSinceResetCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readTimeSinceResetAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsCarrierDetectCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readTimeSinceResetAttribute", - readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readEthernetNetworkDiagnosticsAttributeListCommandParams); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readAttributeListAttribute", - readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsTimeSinceResetCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.put("readTimeSinceResetAttribute", readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.EthernetNetworkDiagnosticsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readEthernetNetworkDiagnosticsAttributeListCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readClusterRevisionAttribute", - readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo); - Map readFixedLabelInteractionInfo = new LinkedHashMap<>(); - Map readFixedLabelLabelListCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelLabelListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readLabelListAttribute( - (ChipClusters.FixedLabelCluster.LabelListAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsFeatureMapCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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 + ); + readEthernetNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo); + Map readFixedLabelInteractionInfo = 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); - readFixedLabelInteractionInfo.put( - "readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); - Map readFixedLabelAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.FixedLabelCluster.AttributeListAttributeCallback) callback); - }, + readFixedLabelLabelListCommandParams + ); + readFixedLabelInteractionInfo.put("readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); + Map readFixedLabelAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster).readAttributeListAttribute( + ( ChipClusters.FixedLabelCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedFixedLabelClusterAttributeListAttributeCallback(), - readFixedLabelAttributeListCommandParams); - readFixedLabelInteractionInfo.put( - "readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); - Map readFixedLabelClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFixedLabelClusterRevisionCommandParams); - readFixedLabelInteractionInfo.put( - "readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("fixedLabel", readFixedLabelInteractionInfo); - Map readFlowMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readFlowMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMeasuredValueCommandParams); - readFlowMeasurementInteractionInfo.put( - "readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMinMeasuredValueCommandParams); - readFlowMeasurementInteractionInfo.put( - "readMinMeasuredValueAttribute", - readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMaxMeasuredValueCommandParams); - readFlowMeasurementInteractionInfo.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); - readFlowMeasurementInteractionInfo.put( - "readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); - Map readFlowMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), - readFlowMeasurementAttributeListCommandParams); - readFlowMeasurementInteractionInfo.put( - "readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); - Map readFlowMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementClusterRevisionCommandParams); - readFlowMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("flowMeasurement", readFlowMeasurementInteractionInfo); - Map readGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readGeneralCommissioningBreadcrumbCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readBreadcrumbAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readFixedLabelAttributeListCommandParams + ); + readFixedLabelInteractionInfo.put("readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); + Map readFixedLabelClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFixedLabelClusterRevisionCommandParams + ); + readFixedLabelInteractionInfo.put("readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("fixedLabel", readFixedLabelInteractionInfo); + Map readFlowMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readFlowMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMeasuredValueCommandParams + ); + readFlowMeasurementInteractionInfo.put("readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readMinMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMinMeasuredValueCommandParams + ); + readFlowMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMaxMeasuredValueCommandParams + ); + readFlowMeasurementInteractionInfo.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 + ); + readFlowMeasurementInteractionInfo.put("readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); + Map readFlowMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), + readFlowMeasurementAttributeListCommandParams + ); + readFlowMeasurementInteractionInfo.put("readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); + Map readFlowMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementClusterRevisionCommandParams + ); + readFlowMeasurementInteractionInfo.put("readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("flowMeasurement", readFlowMeasurementInteractionInfo); + Map readGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readBreadcrumbAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralCommissioningBreadcrumbCommandParams); - readGeneralCommissioningInteractionInfo.put( - "readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); - Map - readGeneralCommissioningBasicCommissioningInfoListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readBasicCommissioningInfoListAttribute( - (ChipClusters.GeneralCommissioningCluster - .BasicCommissioningInfoListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback(), - readGeneralCommissioningBasicCommissioningInfoListCommandParams); - readGeneralCommissioningInteractionInfo.put( - "readBasicCommissioningInfoListAttribute", - readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo); - Map readGeneralCommissioningRegulatoryConfigCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readRegulatoryConfigAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningRegulatoryConfigCommandParams); - readGeneralCommissioningInteractionInfo.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); - readGeneralCommissioningInteractionInfo.put( - "readLocationCapabilityAttribute", - readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); - Map readGeneralCommissioningAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), - readGeneralCommissioningAttributeListCommandParams); - readGeneralCommissioningInteractionInfo.put( - "readAttributeListAttribute", - readGeneralCommissioningAttributeListAttributeInteractionInfo); - Map readGeneralCommissioningClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningClusterRevisionCommandParams); - readGeneralCommissioningInteractionInfo.put( - "readClusterRevisionAttribute", - readGeneralCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("generalCommissioning", readGeneralCommissioningInteractionInfo); - Map readGeneralDiagnosticsInteractionInfo = 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); - readGeneralDiagnosticsInteractionInfo.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); - readGeneralDiagnosticsInteractionInfo.put( - "readRebootCountAttribute", readGeneralDiagnosticsRebootCountAttributeInteractionInfo); - Map readGeneralDiagnosticsUpTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsUpTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readUpTimeAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readGeneralCommissioningBreadcrumbCommandParams + ); + readGeneralCommissioningInteractionInfo.put("readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); + Map readGeneralCommissioningBasicCommissioningInfoListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readBasicCommissioningInfoListAttribute( + ( ChipClusters.GeneralCommissioningCluster.BasicCommissioningInfoListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback(), + readGeneralCommissioningBasicCommissioningInfoListCommandParams + ); + readGeneralCommissioningInteractionInfo.put("readBasicCommissioningInfoListAttribute", readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo); + Map readGeneralCommissioningRegulatoryConfigCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readRegulatoryConfigAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningRegulatoryConfigCommandParams + ); + readGeneralCommissioningInteractionInfo.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 + ); + readGeneralCommissioningInteractionInfo.put("readLocationCapabilityAttribute", readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); + Map readGeneralCommissioningAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readAttributeListAttribute( + ( ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), + readGeneralCommissioningAttributeListCommandParams + ); + readGeneralCommissioningInteractionInfo.put("readAttributeListAttribute", readGeneralCommissioningAttributeListAttributeInteractionInfo); + Map readGeneralCommissioningClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningClusterRevisionCommandParams + ); + readGeneralCommissioningInteractionInfo.put("readClusterRevisionAttribute", readGeneralCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalCommissioning", readGeneralCommissioningInteractionInfo); + Map readGeneralDiagnosticsInteractionInfo = 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 + ); + readGeneralDiagnosticsInteractionInfo.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 + ); + readGeneralDiagnosticsInteractionInfo.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); - readGeneralDiagnosticsInteractionInfo.put( - "readUpTimeAttribute", readGeneralDiagnosticsUpTimeAttributeInteractionInfo); - Map readGeneralDiagnosticsTotalOperationalHoursCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readTotalOperationalHoursAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readGeneralDiagnosticsUpTimeCommandParams + ); + readGeneralDiagnosticsInteractionInfo.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); - readGeneralDiagnosticsInteractionInfo.put( - "readTotalOperationalHoursAttribute", - readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); - Map readGeneralDiagnosticsBootReasonsCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsBootReasonsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readBootReasonsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsBootReasonsCommandParams); - readGeneralDiagnosticsInteractionInfo.put( - "readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeInteractionInfo); - Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readActiveHardwareFaultsAttribute( - (ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), - readGeneralDiagnosticsActiveHardwareFaultsCommandParams); - readGeneralDiagnosticsInteractionInfo.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); - readGeneralDiagnosticsInteractionInfo.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); - readGeneralDiagnosticsInteractionInfo.put( - "readActiveNetworkFaultsAttribute", - readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); - Map readGeneralDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), - readGeneralDiagnosticsAttributeListCommandParams); - readGeneralDiagnosticsInteractionInfo.put( - "readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); - Map readGeneralDiagnosticsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsClusterRevisionCommandParams); - readGeneralDiagnosticsInteractionInfo.put( - "readClusterRevisionAttribute", - readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo); - Map readGroupKeyManagementInteractionInfo = 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); - readGroupKeyManagementInteractionInfo.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); - readGroupKeyManagementInteractionInfo.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); - readGroupKeyManagementInteractionInfo.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); - readGroupKeyManagementInteractionInfo.put( - "readMaxGroupKeysPerFabricAttribute", - readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); - Map readGroupKeyManagementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), - readGroupKeyManagementAttributeListCommandParams); - readGroupKeyManagementInteractionInfo.put( - "readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); - Map readGroupKeyManagementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupKeyManagementClusterRevisionCommandParams); - readGroupKeyManagementInteractionInfo.put( - "readClusterRevisionAttribute", - readGroupKeyManagementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("groupKeyManagement", readGroupKeyManagementInteractionInfo); - Map readGroupsInteractionInfo = new LinkedHashMap<>(); - Map readGroupsNameSupportCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsNameSupportAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readNameSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsNameSupportCommandParams); - readGroupsInteractionInfo.put( - "readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); - Map readGroupsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GroupsCluster.AttributeListAttributeCallback) callback); - }, + readGeneralDiagnosticsTotalOperationalHoursCommandParams + ); + readGeneralDiagnosticsInteractionInfo.put("readTotalOperationalHoursAttribute", readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); + Map readGeneralDiagnosticsBootReasonsCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsBootReasonsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readBootReasonsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsBootReasonsCommandParams + ); + readGeneralDiagnosticsInteractionInfo.put("readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeInteractionInfo); + Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readActiveHardwareFaultsAttribute( + ( ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), + readGeneralDiagnosticsActiveHardwareFaultsCommandParams + ); + readGeneralDiagnosticsInteractionInfo.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 + ); + readGeneralDiagnosticsInteractionInfo.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 + ); + readGeneralDiagnosticsInteractionInfo.put("readActiveNetworkFaultsAttribute", readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); + Map readGeneralDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), + readGeneralDiagnosticsAttributeListCommandParams + ); + readGeneralDiagnosticsInteractionInfo.put("readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); + Map readGeneralDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsClusterRevisionCommandParams + ); + readGeneralDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo); + Map readGroupKeyManagementInteractionInfo = 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 + ); + readGroupKeyManagementInteractionInfo.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 + ); + readGroupKeyManagementInteractionInfo.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 + ); + readGroupKeyManagementInteractionInfo.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 + ); + readGroupKeyManagementInteractionInfo.put("readMaxGroupKeysPerFabricAttribute", readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); + Map readGroupKeyManagementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), + readGroupKeyManagementAttributeListCommandParams + ); + readGroupKeyManagementInteractionInfo.put("readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); + Map readGroupKeyManagementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupKeyManagementClusterRevisionCommandParams + ); + readGroupKeyManagementInteractionInfo.put("readClusterRevisionAttribute", readGroupKeyManagementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groupKeyManagement", readGroupKeyManagementInteractionInfo); + Map readGroupsInteractionInfo = new LinkedHashMap<>(); + Map readGroupsNameSupportCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsNameSupportAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readNameSupportAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsNameSupportCommandParams + ); + readGroupsInteractionInfo.put("readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); + Map readGroupsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.GroupsCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedGroupsClusterAttributeListAttributeCallback(), - readGroupsAttributeListCommandParams); - readGroupsInteractionInfo.put( - "readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); - Map readGroupsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsClusterRevisionCommandParams); - readGroupsInteractionInfo.put( - "readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("groups", readGroupsInteractionInfo); - Map readIdentifyInteractionInfo = new LinkedHashMap<>(); - Map readIdentifyIdentifyTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readIdentifyTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyIdentifyTimeCommandParams); - readIdentifyInteractionInfo.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); - readIdentifyInteractionInfo.put( - "readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); - Map readIdentifyAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.IdentifyCluster.AttributeListAttributeCallback) callback); - }, + readGroupsAttributeListCommandParams + ); + readGroupsInteractionInfo.put("readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); + Map readGroupsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsClusterRevisionCommandParams + ); + readGroupsInteractionInfo.put("readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groups", readGroupsInteractionInfo); + Map readIdentifyInteractionInfo = new LinkedHashMap<>(); + Map readIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readIdentifyTimeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyIdentifyTimeCommandParams + ); + readIdentifyInteractionInfo.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 + ); + readIdentifyInteractionInfo.put("readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); + Map readIdentifyAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readAttributeListAttribute( + ( ChipClusters.IdentifyCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedIdentifyClusterAttributeListAttributeCallback(), - readIdentifyAttributeListCommandParams); - readIdentifyInteractionInfo.put( - "readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); - Map readIdentifyClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyClusterRevisionCommandParams); - readIdentifyInteractionInfo.put( - "readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("identify", readIdentifyInteractionInfo); - Map readIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readIlluminanceMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMeasuredValueCommandParams); - readIlluminanceMeasurementInteractionInfo.put( - "readMeasuredValueAttribute", - readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readMinMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMinMeasuredValueCommandParams); - readIlluminanceMeasurementInteractionInfo.put( - "readMinMeasuredValueAttribute", - readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMaxMeasuredValueCommandParams); - readIlluminanceMeasurementInteractionInfo.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); - readIlluminanceMeasurementInteractionInfo.put( - "readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); - Map readIlluminanceMeasurementLightSensorTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readLightSensorTypeAttribute( - (ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementLightSensorTypeCommandParams); - readIlluminanceMeasurementInteractionInfo.put( - "readLightSensorTypeAttribute", - readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); - Map readIlluminanceMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), - readIlluminanceMeasurementAttributeListCommandParams); - readIlluminanceMeasurementInteractionInfo.put( - "readAttributeListAttribute", - readIlluminanceMeasurementAttributeListAttributeInteractionInfo); - Map readIlluminanceMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementClusterRevisionCommandParams); - readIlluminanceMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", - readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo); - Map readKeypadInputInteractionInfo = new LinkedHashMap<>(); - Map readKeypadInputAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.KeypadInputCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), - readKeypadInputAttributeListCommandParams); - readKeypadInputInteractionInfo.put( - "readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); - Map readKeypadInputClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readKeypadInputClusterRevisionCommandParams); - readKeypadInputInteractionInfo.put( - "readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("keypadInput", readKeypadInputInteractionInfo); - Map readLevelControlInteractionInfo = new LinkedHashMap<>(); - Map readLevelControlCurrentLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readCurrentLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlCurrentLevelCommandParams); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.put( - "readOnOffTransitionTimeAttribute", - readLevelControlOnOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlOnLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readOnLevelAttribute( - (ChipClusters.LevelControlCluster.OnLevelAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnLevelCommandParams); - readLevelControlInteractionInfo.put( - "readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); - Map readLevelControlOnTransitionTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readOnTransitionTimeAttribute( - (ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnTransitionTimeCommandParams); - readLevelControlInteractionInfo.put( - "readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); - Map readLevelControlOffTransitionTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readOffTransitionTimeAttribute( - (ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOffTransitionTimeCommandParams); - readLevelControlInteractionInfo.put( - "readOffTransitionTimeAttribute", - readLevelControlOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlDefaultMoveRateCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readDefaultMoveRateAttribute( - (ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlDefaultMoveRateCommandParams); - readLevelControlInteractionInfo.put( - "readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); - Map readLevelControlStartUpCurrentLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readStartUpCurrentLevelAttribute( - (ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlStartUpCurrentLevelCommandParams); - readLevelControlInteractionInfo.put( - "readStartUpCurrentLevelAttribute", - readLevelControlStartUpCurrentLevelAttributeInteractionInfo); - Map readLevelControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.LevelControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), - readLevelControlAttributeListCommandParams); - readLevelControlInteractionInfo.put( - "readAttributeListAttribute", readLevelControlAttributeListAttributeInteractionInfo); - Map readLevelControlFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readIdentifyAttributeListCommandParams + ); + readIdentifyInteractionInfo.put("readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); + Map readIdentifyClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyClusterRevisionCommandParams + ); + readIdentifyInteractionInfo.put("readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("identify", readIdentifyInteractionInfo); + Map readIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readIlluminanceMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMeasuredValueAttribute( + ( ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMeasuredValueCommandParams + ); + readIlluminanceMeasurementInteractionInfo.put("readMeasuredValueAttribute", readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMinMeasuredValueAttribute( + ( ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMinMeasuredValueCommandParams + ); + readIlluminanceMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + ( ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMaxMeasuredValueCommandParams + ); + readIlluminanceMeasurementInteractionInfo.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 + ); + readIlluminanceMeasurementInteractionInfo.put("readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); + Map readIlluminanceMeasurementLightSensorTypeCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readLightSensorTypeAttribute( + ( ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementLightSensorTypeCommandParams + ); + readIlluminanceMeasurementInteractionInfo.put("readLightSensorTypeAttribute", readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); + Map readIlluminanceMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), + readIlluminanceMeasurementAttributeListCommandParams + ); + readIlluminanceMeasurementInteractionInfo.put("readAttributeListAttribute", readIlluminanceMeasurementAttributeListAttributeInteractionInfo); + Map readIlluminanceMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementClusterRevisionCommandParams + ); + readIlluminanceMeasurementInteractionInfo.put("readClusterRevisionAttribute", readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo); + Map readKeypadInputInteractionInfo = new LinkedHashMap<>(); + Map readKeypadInputAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster).readAttributeListAttribute( + ( ChipClusters.KeypadInputCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), + readKeypadInputAttributeListCommandParams + ); + readKeypadInputInteractionInfo.put("readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); + Map readKeypadInputClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readKeypadInputClusterRevisionCommandParams + ); + readKeypadInputInteractionInfo.put("readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("keypadInput", readKeypadInputInteractionInfo); + Map readLevelControlInteractionInfo = new LinkedHashMap<>(); + Map readLevelControlCurrentLevelCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readCurrentLevelAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlCurrentLevelCommandParams + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.put("readOnOffTransitionTimeAttribute", readLevelControlOnOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlOnLevelCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readOnLevelAttribute( + ( ChipClusters.LevelControlCluster.OnLevelAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnLevelCommandParams + ); + readLevelControlInteractionInfo.put("readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); + Map readLevelControlOnTransitionTimeCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readOnTransitionTimeAttribute( + ( ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnTransitionTimeCommandParams + ); + readLevelControlInteractionInfo.put("readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); + Map readLevelControlOffTransitionTimeCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readOffTransitionTimeAttribute( + ( ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOffTransitionTimeCommandParams + ); + readLevelControlInteractionInfo.put("readOffTransitionTimeAttribute", readLevelControlOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlDefaultMoveRateCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readDefaultMoveRateAttribute( + ( ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlDefaultMoveRateCommandParams + ); + readLevelControlInteractionInfo.put("readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); + Map readLevelControlStartUpCurrentLevelCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readStartUpCurrentLevelAttribute( + ( ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlStartUpCurrentLevelCommandParams + ); + readLevelControlInteractionInfo.put("readStartUpCurrentLevelAttribute", readLevelControlStartUpCurrentLevelAttributeInteractionInfo); + Map readLevelControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readAttributeListAttribute( + ( ChipClusters.LevelControlCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), + readLevelControlAttributeListCommandParams + ); + readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.put( - "readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("levelControl", readLevelControlInteractionInfo); - Map readLocalizationConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map readLocalizationConfigurationActiveLocaleCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readActiveLocaleAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readLevelControlFeatureMapCommandParams + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.put("readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("levelControl", readLevelControlInteractionInfo); + Map readLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); + Map readLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readActiveLocaleAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readLocalizationConfigurationActiveLocaleCommandParams); - readLocalizationConfigurationInteractionInfo.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); - readLocalizationConfigurationInteractionInfo.put( - "readSupportedLocalesAttribute", - readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); - Map readLocalizationConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLocalizationConfigurationClusterRevisionCommandParams); - readLocalizationConfigurationInteractionInfo.put( - "readClusterRevisionAttribute", - readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("localizationConfiguration", readLocalizationConfigurationInteractionInfo); - Map readLowPowerInteractionInfo = new LinkedHashMap<>(); - Map readLowPowerAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.LowPowerCluster.AttributeListAttributeCallback) callback); - }, + readLocalizationConfigurationActiveLocaleCommandParams + ); + readLocalizationConfigurationInteractionInfo.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 + ); + readLocalizationConfigurationInteractionInfo.put("readSupportedLocalesAttribute", readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); + Map readLocalizationConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLocalizationConfigurationClusterRevisionCommandParams + ); + readLocalizationConfigurationInteractionInfo.put("readClusterRevisionAttribute", readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("localizationConfiguration", readLocalizationConfigurationInteractionInfo); + Map readLowPowerInteractionInfo = new LinkedHashMap<>(); + Map readLowPowerAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).readAttributeListAttribute( + ( ChipClusters.LowPowerCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLowPowerClusterAttributeListAttributeCallback(), - readLowPowerAttributeListCommandParams); - readLowPowerInteractionInfo.put( - "readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); - Map readLowPowerClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLowPowerClusterRevisionCommandParams); - readLowPowerInteractionInfo.put( - "readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("lowPower", readLowPowerInteractionInfo); - Map readMediaInputInteractionInfo = new LinkedHashMap<>(); - Map readMediaInputMediaInputListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputMediaInputListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readMediaInputListAttribute( - (ChipClusters.MediaInputCluster.MediaInputListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedMediaInputClusterMediaInputListAttributeCallback(), - readMediaInputMediaInputListCommandParams); - readMediaInputInteractionInfo.put( - "readMediaInputListAttribute", readMediaInputMediaInputListAttributeInteractionInfo); - Map readMediaInputCurrentMediaInputCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputCurrentMediaInputAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readCurrentMediaInputAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputCurrentMediaInputCommandParams); - readMediaInputInteractionInfo.put( - "readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeInteractionInfo); - Map readMediaInputAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.MediaInputCluster.AttributeListAttributeCallback) callback); - }, + readLowPowerAttributeListCommandParams + ); + readLowPowerInteractionInfo.put("readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); + Map readLowPowerClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLowPowerClusterRevisionCommandParams + ); + readLowPowerInteractionInfo.put("readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("lowPower", readLowPowerInteractionInfo); + Map readMediaInputInteractionInfo = new LinkedHashMap<>(); + Map readMediaInputMediaInputListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputMediaInputListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readMediaInputListAttribute( + ( ChipClusters.MediaInputCluster.MediaInputListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaInputClusterMediaInputListAttributeCallback(), + readMediaInputMediaInputListCommandParams + ); + readMediaInputInteractionInfo.put("readMediaInputListAttribute", readMediaInputMediaInputListAttributeInteractionInfo); + Map readMediaInputCurrentMediaInputCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputCurrentMediaInputAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readCurrentMediaInputAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputCurrentMediaInputCommandParams + ); + readMediaInputInteractionInfo.put("readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeInteractionInfo); + Map readMediaInputAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readAttributeListAttribute( + ( ChipClusters.MediaInputCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedMediaInputClusterAttributeListAttributeCallback(), - readMediaInputAttributeListCommandParams); - readMediaInputInteractionInfo.put( - "readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); - Map readMediaInputClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputClusterRevisionCommandParams); - readMediaInputInteractionInfo.put( - "readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("mediaInput", readMediaInputInteractionInfo); - Map readMediaPlaybackInteractionInfo = new LinkedHashMap<>(); - Map readMediaPlaybackPlaybackStateCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readPlaybackStateAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackPlaybackStateCommandParams); - readMediaPlaybackInteractionInfo.put( - "readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeInteractionInfo); - Map readMediaPlaybackStartTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readStartTimeAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readMediaInputAttributeListCommandParams + ); + readMediaInputInteractionInfo.put("readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); + Map readMediaInputClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputClusterRevisionCommandParams + ); + readMediaInputInteractionInfo.put("readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaInput", readMediaInputInteractionInfo); + Map readMediaPlaybackInteractionInfo = new LinkedHashMap<>(); + Map readMediaPlaybackPlaybackStateCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackPlaybackStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readPlaybackStateAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackPlaybackStateCommandParams + ); + readMediaPlaybackInteractionInfo.put("readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeInteractionInfo); + Map readMediaPlaybackStartTimeCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readStartTimeAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackStartTimeCommandParams); - readMediaPlaybackInteractionInfo.put( - "readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); - Map readMediaPlaybackDurationCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readDurationAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readMediaPlaybackStartTimeCommandParams + ); + readMediaPlaybackInteractionInfo.put("readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); + Map readMediaPlaybackDurationCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readDurationAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackDurationCommandParams); - readMediaPlaybackInteractionInfo.put( - "readDurationAttribute", readMediaPlaybackDurationAttributeInteractionInfo); - Map readMediaPlaybackPlaybackSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readPlaybackSpeedAttribute((ChipClusters.FloatAttributeCallback) callback); - }, + readMediaPlaybackDurationCommandParams + ); + readMediaPlaybackInteractionInfo.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); - readMediaPlaybackInteractionInfo.put( - "readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeEndCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readSeekRangeEndAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readMediaPlaybackPlaybackSpeedCommandParams + ); + readMediaPlaybackInteractionInfo.put("readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeEndCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeEndAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackSeekRangeEndCommandParams); - readMediaPlaybackInteractionInfo.put( - "readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeStartCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readSeekRangeStartAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readMediaPlaybackSeekRangeEndCommandParams + ); + readMediaPlaybackInteractionInfo.put("readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeStartCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeStartAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackSeekRangeStartCommandParams); - readMediaPlaybackInteractionInfo.put( - "readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); - Map readMediaPlaybackAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), - readMediaPlaybackAttributeListCommandParams); - readMediaPlaybackInteractionInfo.put( - "readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); - Map readMediaPlaybackClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackClusterRevisionCommandParams); - readMediaPlaybackInteractionInfo.put( - "readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("mediaPlayback", readMediaPlaybackInteractionInfo); - Map readModeSelectInteractionInfo = new LinkedHashMap<>(); - Map readModeSelectCurrentModeCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readCurrentModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectCurrentModeCommandParams); - readModeSelectInteractionInfo.put( - "readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); - Map readModeSelectSupportedModesCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readSupportedModesAttribute( - (ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), - readModeSelectSupportedModesCommandParams); - readModeSelectInteractionInfo.put( - "readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); - Map readModeSelectOnModeCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectOnModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readOnModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectOnModeCommandParams); - readModeSelectInteractionInfo.put( - "readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); - Map readModeSelectStartUpModeCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readStartUpModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectStartUpModeCommandParams); - readModeSelectInteractionInfo.put( - "readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); - Map readModeSelectDescriptionCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readMediaPlaybackSeekRangeStartCommandParams + ); + readMediaPlaybackInteractionInfo.put("readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); + Map readMediaPlaybackAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readAttributeListAttribute( + ( ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), + readMediaPlaybackAttributeListCommandParams + ); + readMediaPlaybackInteractionInfo.put("readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); + Map readMediaPlaybackClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackClusterRevisionCommandParams + ); + readMediaPlaybackInteractionInfo.put("readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaPlayback", readMediaPlaybackInteractionInfo); + Map readModeSelectInteractionInfo = new LinkedHashMap<>(); + Map readModeSelectCurrentModeCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readCurrentModeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectCurrentModeCommandParams + ); + readModeSelectInteractionInfo.put("readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); + Map readModeSelectSupportedModesCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readSupportedModesAttribute( + ( ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), + readModeSelectSupportedModesCommandParams + ); + readModeSelectInteractionInfo.put("readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); + Map readModeSelectOnModeCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectOnModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readOnModeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectOnModeCommandParams + ); + readModeSelectInteractionInfo.put("readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); + Map readModeSelectStartUpModeCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readStartUpModeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectStartUpModeCommandParams + ); + readModeSelectInteractionInfo.put("readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); + Map readModeSelectDescriptionCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readDescriptionAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readModeSelectDescriptionCommandParams); - readModeSelectInteractionInfo.put( - "readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); - Map readModeSelectAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ModeSelectCluster.AttributeListAttributeCallback) callback); - }, + readModeSelectDescriptionCommandParams + ); + readModeSelectInteractionInfo.put("readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); + Map readModeSelectAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ModeSelectCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedModeSelectClusterAttributeListAttributeCallback(), - readModeSelectAttributeListCommandParams); - readModeSelectInteractionInfo.put( - "readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); - Map readModeSelectClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectClusterRevisionCommandParams); - readModeSelectInteractionInfo.put( - "readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("modeSelect", readModeSelectInteractionInfo); - Map readNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readNetworkCommissioningMaxNetworksCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readMaxNetworksAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningMaxNetworksCommandParams); - readNetworkCommissioningInteractionInfo.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); - readNetworkCommissioningInteractionInfo.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); - readNetworkCommissioningInteractionInfo.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); - readNetworkCommissioningInteractionInfo.put( - "readConnectMaxTimeSecondsAttribute", - readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo); - Map readNetworkCommissioningInterfaceEnabledCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readInterfaceEnabledAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readModeSelectAttributeListCommandParams + ); + readModeSelectInteractionInfo.put("readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); + Map readModeSelectClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectClusterRevisionCommandParams + ); + readModeSelectInteractionInfo.put("readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("modeSelect", readModeSelectInteractionInfo); + Map readNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readNetworkCommissioningMaxNetworksCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readMaxNetworksAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningMaxNetworksCommandParams + ); + readNetworkCommissioningInteractionInfo.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 + ); + readNetworkCommissioningInteractionInfo.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 + ); + readNetworkCommissioningInteractionInfo.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 + ); + readNetworkCommissioningInteractionInfo.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); - readNetworkCommissioningInteractionInfo.put( - "readInterfaceEnabledAttribute", - readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkingStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readLastNetworkingStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningLastNetworkingStatusCommandParams); - readNetworkCommissioningInteractionInfo.put( - "readLastNetworkingStatusAttribute", - readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkIDCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readLastNetworkIDAttribute((ChipClusters.OctetStringAttributeCallback) callback); - }, + readNetworkCommissioningInterfaceEnabledCommandParams + ); + readNetworkCommissioningInteractionInfo.put("readInterfaceEnabledAttribute", readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkingStatusCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkingStatusAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningLastNetworkingStatusCommandParams + ); + readNetworkCommissioningInteractionInfo.put("readLastNetworkingStatusAttribute", readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkIDCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkIDAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readNetworkCommissioningLastNetworkIDCommandParams); - readNetworkCommissioningInteractionInfo.put( - "readLastNetworkIDAttribute", - readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); - Map readNetworkCommissioningLastConnectErrorValueCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readLastConnectErrorValueAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readNetworkCommissioningLastNetworkIDCommandParams + ); + readNetworkCommissioningInteractionInfo.put("readLastNetworkIDAttribute", readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); + Map readNetworkCommissioningLastConnectErrorValueCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readLastConnectErrorValueAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningLastConnectErrorValueCommandParams); - readNetworkCommissioningInteractionInfo.put( - "readLastConnectErrorValueAttribute", - readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); - Map readNetworkCommissioningFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readNetworkCommissioningLastConnectErrorValueCommandParams + ); + readNetworkCommissioningInteractionInfo.put("readLastConnectErrorValueAttribute", readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); + Map readNetworkCommissioningFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readFeatureMapAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningFeatureMapCommandParams); - readNetworkCommissioningInteractionInfo.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); - readNetworkCommissioningInteractionInfo.put( - "readClusterRevisionAttribute", - readNetworkCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("networkCommissioning", readNetworkCommissioningInteractionInfo); - Map readOtaSoftwareUpdateProviderInteractionInfo = - new LinkedHashMap<>(); - Map readOtaSoftwareUpdateProviderAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateProviderAttributeListCommandParams); - readOtaSoftwareUpdateProviderInteractionInfo.put( - "readAttributeListAttribute", - readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateProviderClusterRevisionCommandParams); - readOtaSoftwareUpdateProviderInteractionInfo.put( - "readClusterRevisionAttribute", - readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo); - Map readOtaSoftwareUpdateRequestorInteractionInfo = - 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); - readOtaSoftwareUpdateRequestorInteractionInfo.put( - "readDefaultOtaProvidersAttribute", - readOtaSoftwareUpdateRequestorDefaultOtaProvidersAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readUpdatePossibleAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readNetworkCommissioningFeatureMapCommandParams + ); + readNetworkCommissioningInteractionInfo.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 + ); + readNetworkCommissioningInteractionInfo.put("readClusterRevisionAttribute", readNetworkCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("networkCommissioning", readNetworkCommissioningInteractionInfo); + Map readOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); + Map readOtaSoftwareUpdateProviderAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateProviderAttributeListCommandParams + ); + readOtaSoftwareUpdateProviderInteractionInfo.put("readAttributeListAttribute", readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateProviderClusterRevisionCommandParams + ); + readOtaSoftwareUpdateProviderInteractionInfo.put("readClusterRevisionAttribute", readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo); + Map readOtaSoftwareUpdateRequestorInteractionInfo = 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 + ); + readOtaSoftwareUpdateRequestorInteractionInfo.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); - readOtaSoftwareUpdateRequestorInteractionInfo.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); - readOtaSoftwareUpdateRequestorInteractionInfo.put( - "readUpdateStateAttribute", - readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); - Map - readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readUpdateStateProgressAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster - .UpdateStateProgressAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams); - readOtaSoftwareUpdateRequestorInteractionInfo.put( - "readUpdateStateProgressAttribute", - readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateRequestorAttributeListCommandParams); - readOtaSoftwareUpdateRequestorInteractionInfo.put( - "readAttributeListAttribute", - readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorClusterRevisionCommandParams); - readOtaSoftwareUpdateRequestorInteractionInfo.put( - "readClusterRevisionAttribute", - readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo); - Map readOccupancySensingInteractionInfo = new LinkedHashMap<>(); - Map readOccupancySensingOccupancyCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readOccupancyAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingOccupancyCommandParams); - readOccupancySensingInteractionInfo.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); - readOccupancySensingInteractionInfo.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); - readOccupancySensingInteractionInfo.put( - "readOccupancySensorTypeBitmapAttribute", - readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); - Map readOccupancySensingAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOccupancySensingClusterAttributeListAttributeCallback(), - readOccupancySensingAttributeListCommandParams); - readOccupancySensingInteractionInfo.put( - "readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); - Map readOccupancySensingClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingClusterRevisionCommandParams); - readOccupancySensingInteractionInfo.put( - "readClusterRevisionAttribute", - readOccupancySensingClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("occupancySensing", readOccupancySensingInteractionInfo); - Map readOnOffInteractionInfo = new LinkedHashMap<>(); - Map readOnOffOnOffCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffOnOffAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readOnOffAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams + ); + readOtaSoftwareUpdateRequestorInteractionInfo.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 + ); + readOtaSoftwareUpdateRequestorInteractionInfo.put("readUpdateStateAttribute", readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdateStateProgressAttribute( + ( ChipClusters.OtaSoftwareUpdateRequestorCluster.UpdateStateProgressAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams + ); + readOtaSoftwareUpdateRequestorInteractionInfo.put("readUpdateStateProgressAttribute", readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OtaSoftwareUpdateRequestorCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateRequestorAttributeListCommandParams + ); + readOtaSoftwareUpdateRequestorInteractionInfo.put("readAttributeListAttribute", readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorClusterRevisionCommandParams + ); + readOtaSoftwareUpdateRequestorInteractionInfo.put("readClusterRevisionAttribute", readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo); + Map readOccupancySensingInteractionInfo = new LinkedHashMap<>(); + Map readOccupancySensingOccupancyCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readOccupancyAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingOccupancyCommandParams + ); + readOccupancySensingInteractionInfo.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 + ); + readOccupancySensingInteractionInfo.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 + ); + readOccupancySensingInteractionInfo.put("readOccupancySensorTypeBitmapAttribute", readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); + Map readOccupancySensingAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterAttributeListAttributeCallback(), + readOccupancySensingAttributeListCommandParams + ); + readOccupancySensingInteractionInfo.put("readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); + Map readOccupancySensingClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingClusterRevisionCommandParams + ); + readOccupancySensingInteractionInfo.put("readClusterRevisionAttribute", readOccupancySensingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("occupancySensing", readOccupancySensingInteractionInfo); + Map readOnOffInteractionInfo = new LinkedHashMap<>(); + Map readOnOffOnOffCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffOnOffAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readOnOffAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOnOffOnOffCommandParams); - readOnOffInteractionInfo.put("readOnOffAttribute", readOnOffOnOffAttributeInteractionInfo); - Map readOnOffGlobalSceneControlCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffGlobalSceneControlAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readGlobalSceneControlAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readOnOffOnOffCommandParams + ); + readOnOffInteractionInfo.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); - readOnOffInteractionInfo.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); - readOnOffInteractionInfo.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); - readOnOffInteractionInfo.put( - "readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); - Map readOnOffStartUpOnOffCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readStartUpOnOffAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffStartUpOnOffCommandParams); - readOnOffInteractionInfo.put( - "readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); - Map readOnOffAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OnOffCluster.AttributeListAttributeCallback) callback); - }, + readOnOffGlobalSceneControlCommandParams + ); + readOnOffInteractionInfo.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 + ); + readOnOffInteractionInfo.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 + ); + readOnOffInteractionInfo.put("readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); + Map readOnOffStartUpOnOffCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readStartUpOnOffAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffStartUpOnOffCommandParams + ); + readOnOffInteractionInfo.put("readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); + Map readOnOffAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OnOffCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOnOffClusterAttributeListAttributeCallback(), - readOnOffAttributeListCommandParams); - readOnOffInteractionInfo.put( - "readAttributeListAttribute", readOnOffAttributeListAttributeInteractionInfo); - Map readOnOffFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readOnOffAttributeListCommandParams + ); + readOnOffInteractionInfo.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); - readOnOffInteractionInfo.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); - readOnOffInteractionInfo.put( - "readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("onOff", readOnOffInteractionInfo); - Map readOnOffSwitchConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map readOnOffSwitchConfigurationSwitchTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readSwitchTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationSwitchTypeCommandParams); - readOnOffSwitchConfigurationInteractionInfo.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); - readOnOffSwitchConfigurationInteractionInfo.put( - "readSwitchActionsAttribute", - readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); - Map readOnOffSwitchConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), - readOnOffSwitchConfigurationAttributeListCommandParams); - readOnOffSwitchConfigurationInteractionInfo.put( - "readAttributeListAttribute", - readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationClusterRevisionCommandParams); - readOnOffSwitchConfigurationInteractionInfo.put( - "readClusterRevisionAttribute", - readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo); - Map readOperationalCredentialsInteractionInfo = 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); - readOperationalCredentialsInteractionInfo.put( - "readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); - Map readOperationalCredentialsFabricsListCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsFabricsListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readFabricsListAttribute( - (ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOperationalCredentialsClusterFabricsListAttributeCallback(), - readOperationalCredentialsFabricsListCommandParams); - readOperationalCredentialsInteractionInfo.put( - "readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeInteractionInfo); - Map readOperationalCredentialsSupportedFabricsCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readSupportedFabricsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsSupportedFabricsCommandParams); - readOperationalCredentialsInteractionInfo.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); - readOperationalCredentialsInteractionInfo.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); - readOperationalCredentialsInteractionInfo.put( - "readTrustedRootCertificatesAttribute", - readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); - Map readOperationalCredentialsCurrentFabricIndexCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readCurrentFabricIndexAttribute( - (ChipClusters.OperationalCredentialsCluster - .CurrentFabricIndexAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsCurrentFabricIndexCommandParams); - readOperationalCredentialsInteractionInfo.put( - "readCurrentFabricIndexAttribute", - readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); - Map readOperationalCredentialsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), - readOperationalCredentialsAttributeListCommandParams); - readOperationalCredentialsInteractionInfo.put( - "readAttributeListAttribute", - readOperationalCredentialsAttributeListAttributeInteractionInfo); - Map readOperationalCredentialsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsClusterRevisionCommandParams); - readOperationalCredentialsInteractionInfo.put( - "readClusterRevisionAttribute", - readOperationalCredentialsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("operationalCredentials", readOperationalCredentialsInteractionInfo); - Map readPowerSourceInteractionInfo = new LinkedHashMap<>(); - Map readPowerSourceStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceStatusCommandParams); - readPowerSourceInteractionInfo.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); - readPowerSourceInteractionInfo.put( - "readOrderAttribute", readPowerSourceOrderAttributeInteractionInfo); - Map readPowerSourceDescriptionCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceDescriptionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readOnOffFeatureMapCommandParams + ); + readOnOffInteractionInfo.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 + ); + readOnOffInteractionInfo.put("readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOff", readOnOffInteractionInfo); + Map readOnOffSwitchConfigurationInteractionInfo = new LinkedHashMap<>(); + Map readOnOffSwitchConfigurationSwitchTypeCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readSwitchTypeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationSwitchTypeCommandParams + ); + readOnOffSwitchConfigurationInteractionInfo.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 + ); + readOnOffSwitchConfigurationInteractionInfo.put("readSwitchActionsAttribute", readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); + Map readOnOffSwitchConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), + readOnOffSwitchConfigurationAttributeListCommandParams + ); + readOnOffSwitchConfigurationInteractionInfo.put("readAttributeListAttribute", readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationClusterRevisionCommandParams + ); + readOnOffSwitchConfigurationInteractionInfo.put("readClusterRevisionAttribute", readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo); + Map readOperationalCredentialsInteractionInfo = 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 + ); + readOperationalCredentialsInteractionInfo.put("readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); + Map readOperationalCredentialsFabricsListCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsFabricsListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readFabricsListAttribute( + ( ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterFabricsListAttributeCallback(), + readOperationalCredentialsFabricsListCommandParams + ); + readOperationalCredentialsInteractionInfo.put("readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeInteractionInfo); + Map readOperationalCredentialsSupportedFabricsCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readSupportedFabricsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsSupportedFabricsCommandParams + ); + readOperationalCredentialsInteractionInfo.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 + ); + readOperationalCredentialsInteractionInfo.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 + ); + readOperationalCredentialsInteractionInfo.put("readTrustedRootCertificatesAttribute", readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); + Map readOperationalCredentialsCurrentFabricIndexCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readCurrentFabricIndexAttribute( + ( ChipClusters.OperationalCredentialsCluster.CurrentFabricIndexAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsCurrentFabricIndexCommandParams + ); + readOperationalCredentialsInteractionInfo.put("readCurrentFabricIndexAttribute", readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); + Map readOperationalCredentialsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), + readOperationalCredentialsAttributeListCommandParams + ); + readOperationalCredentialsInteractionInfo.put("readAttributeListAttribute", readOperationalCredentialsAttributeListAttributeInteractionInfo); + Map readOperationalCredentialsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsClusterRevisionCommandParams + ); + readOperationalCredentialsInteractionInfo.put("readClusterRevisionAttribute", readOperationalCredentialsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("operationalCredentials", readOperationalCredentialsInteractionInfo); + Map readPowerSourceInteractionInfo = new LinkedHashMap<>(); + Map readPowerSourceStatusCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readStatusAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceStatusCommandParams + ); + readPowerSourceInteractionInfo.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 + ); + readPowerSourceInteractionInfo.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); - readPowerSourceInteractionInfo.put( - "readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); - Map readPowerSourceBatteryVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatteryVoltageAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readPowerSourceDescriptionCommandParams + ); + readPowerSourceInteractionInfo.put("readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); + Map readPowerSourceBatteryVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatteryVoltageAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatteryVoltageCommandParams); - readPowerSourceInteractionInfo.put( - "readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeInteractionInfo); - Map readPowerSourceBatteryPercentRemainingCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryPercentRemainingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatteryPercentRemainingAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryPercentRemainingCommandParams); - readPowerSourceInteractionInfo.put( - "readBatteryPercentRemainingAttribute", - readPowerSourceBatteryPercentRemainingAttributeInteractionInfo); - Map readPowerSourceBatteryTimeRemainingCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryTimeRemainingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatteryTimeRemainingAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readPowerSourceBatteryVoltageCommandParams + ); + readPowerSourceInteractionInfo.put("readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeInteractionInfo); + Map readPowerSourceBatteryPercentRemainingCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryPercentRemainingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatteryPercentRemainingAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryPercentRemainingCommandParams + ); + readPowerSourceInteractionInfo.put("readBatteryPercentRemainingAttribute", readPowerSourceBatteryPercentRemainingAttributeInteractionInfo); + Map readPowerSourceBatteryTimeRemainingCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryTimeRemainingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatteryTimeRemainingAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatteryTimeRemainingCommandParams); - readPowerSourceInteractionInfo.put( - "readBatteryTimeRemainingAttribute", - readPowerSourceBatteryTimeRemainingAttributeInteractionInfo); - Map readPowerSourceBatteryChargeLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryChargeLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatteryChargeLevelAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryChargeLevelCommandParams); - readPowerSourceInteractionInfo.put( - "readBatteryChargeLevelAttribute", - readPowerSourceBatteryChargeLevelAttributeInteractionInfo); - Map readPowerSourceActiveBatteryFaultsCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceActiveBatteryFaultsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readActiveBatteryFaultsAttribute( - (ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback(), - readPowerSourceActiveBatteryFaultsCommandParams); - readPowerSourceInteractionInfo.put( - "readActiveBatteryFaultsAttribute", - readPowerSourceActiveBatteryFaultsAttributeInteractionInfo); - Map readPowerSourceBatteryChargeStateCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryChargeStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatteryChargeStateAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryChargeStateCommandParams); - readPowerSourceInteractionInfo.put( - "readBatteryChargeStateAttribute", - readPowerSourceBatteryChargeStateAttributeInteractionInfo); - Map readPowerSourceAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PowerSourceCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), - readPowerSourceAttributeListCommandParams); - readPowerSourceInteractionInfo.put( - "readAttributeListAttribute", readPowerSourceAttributeListAttributeInteractionInfo); - Map readPowerSourceFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readPowerSourceBatteryTimeRemainingCommandParams + ); + readPowerSourceInteractionInfo.put("readBatteryTimeRemainingAttribute", readPowerSourceBatteryTimeRemainingAttributeInteractionInfo); + Map readPowerSourceBatteryChargeLevelCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryChargeLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatteryChargeLevelAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryChargeLevelCommandParams + ); + readPowerSourceInteractionInfo.put("readBatteryChargeLevelAttribute", readPowerSourceBatteryChargeLevelAttributeInteractionInfo); + Map readPowerSourceActiveBatteryFaultsCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceActiveBatteryFaultsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readActiveBatteryFaultsAttribute( + ( ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback(), + readPowerSourceActiveBatteryFaultsCommandParams + ); + readPowerSourceInteractionInfo.put("readActiveBatteryFaultsAttribute", readPowerSourceActiveBatteryFaultsAttributeInteractionInfo); + Map readPowerSourceBatteryChargeStateCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryChargeStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatteryChargeStateAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryChargeStateCommandParams + ); + readPowerSourceInteractionInfo.put("readBatteryChargeStateAttribute", readPowerSourceBatteryChargeStateAttributeInteractionInfo); + Map readPowerSourceAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readAttributeListAttribute( + ( ChipClusters.PowerSourceCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), + readPowerSourceAttributeListCommandParams + ); + readPowerSourceInteractionInfo.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); - readPowerSourceInteractionInfo.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); - readPowerSourceInteractionInfo.put( - "readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("powerSource", readPowerSourceInteractionInfo); - Map readPowerSourceConfigurationInteractionInfo = - 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); - readPowerSourceConfigurationInteractionInfo.put( - "readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); - Map readPowerSourceConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), - readPowerSourceConfigurationAttributeListCommandParams); - readPowerSourceConfigurationInteractionInfo.put( - "readAttributeListAttribute", - readPowerSourceConfigurationAttributeListAttributeInteractionInfo); - Map readPowerSourceConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceConfigurationClusterRevisionCommandParams); - readPowerSourceConfigurationInteractionInfo.put( - "readClusterRevisionAttribute", - readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo); - Map readPressureMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readPressureMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMeasuredValueCommandParams); - readPressureMeasurementInteractionInfo.put( - "readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMinMeasuredValueCommandParams); - readPressureMeasurementInteractionInfo.put( - "readMinMeasuredValueAttribute", - readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMaxMeasuredValueCommandParams); - readPressureMeasurementInteractionInfo.put( - "readMaxMeasuredValueAttribute", - readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), - readPressureMeasurementAttributeListCommandParams); - readPressureMeasurementInteractionInfo.put( - "readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); - Map readPressureMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementClusterRevisionCommandParams); - readPressureMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", - readPressureMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("pressureMeasurement", readPressureMeasurementInteractionInfo); - Map readPumpConfigurationAndControlInteractionInfo = - new LinkedHashMap<>(); - Map readPumpConfigurationAndControlMaxPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxPressureCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxPressureAttribute", - readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxSpeedCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxFlowCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxFlowCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstPressureCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMinConstPressureAttribute", - readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstPressureCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxConstPressureAttribute", - readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinCompPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinCompPressureCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMinCompPressureAttribute", - readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxCompPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxCompPressureCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxCompPressureAttribute", - readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstSpeedCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMinConstSpeedAttribute", - readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstSpeedCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxConstSpeedAttribute", - readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstFlowCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstFlowCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMinConstFlowAttribute", - readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstFlowCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstFlowCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxConstFlowAttribute", - readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstTempCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstTempCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMinConstTempAttribute", - readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstTempCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstTempCommandParams); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.put( - "readEffectiveControlModeAttribute", - readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlCapacityCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readCapacityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlCapacityCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); - Map readPumpConfigurationAndControlSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlSpeedCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); - Map - readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readLifetimeRunningHoursAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .LifetimeRunningHoursAttributeCallback) - callback); - }, + readPowerSourceFeatureMapCommandParams + ); + readPowerSourceInteractionInfo.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 + ); + readPowerSourceInteractionInfo.put("readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("powerSource", readPowerSourceInteractionInfo); + Map readPowerSourceConfigurationInteractionInfo = 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 + ); + readPowerSourceConfigurationInteractionInfo.put("readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); + Map readPowerSourceConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster).readAttributeListAttribute( + ( ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), + readPowerSourceConfigurationAttributeListCommandParams + ); + readPowerSourceConfigurationInteractionInfo.put("readAttributeListAttribute", readPowerSourceConfigurationAttributeListAttributeInteractionInfo); + Map readPowerSourceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceConfigurationClusterRevisionCommandParams + ); + readPowerSourceConfigurationInteractionInfo.put("readClusterRevisionAttribute", readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo); + Map readPressureMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readPressureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMeasuredValueCommandParams + ); + readPressureMeasurementInteractionInfo.put("readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readMinMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMinMeasuredValueCommandParams + ); + readPressureMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMaxMeasuredValueCommandParams + ); + readPressureMeasurementInteractionInfo.put("readMaxMeasuredValueAttribute", readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), + readPressureMeasurementAttributeListCommandParams + ); + readPressureMeasurementInteractionInfo.put("readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); + Map readPressureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementClusterRevisionCommandParams + ); + readPressureMeasurementInteractionInfo.put("readClusterRevisionAttribute", readPressureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("pressureMeasurement", readPressureMeasurementInteractionInfo); + Map readPumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); + Map readPumpConfigurationAndControlMaxPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxPressureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxPressureCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxPressureAttribute", readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxSpeedAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxSpeedCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxFlowCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxFlowAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxFlowCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstPressureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstPressureCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMinConstPressureAttribute", readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstPressureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstPressureCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxConstPressureAttribute", readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinCompPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinCompPressureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinCompPressureCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMinCompPressureAttribute", readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxCompPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxCompPressureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxCompPressureCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxCompPressureAttribute", readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstSpeedAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstSpeedCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMinConstSpeedAttribute", readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstSpeedAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstSpeedCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxConstSpeedAttribute", readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstFlowCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstFlowAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstFlowCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMinConstFlowAttribute", readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstFlowCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstFlowAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstFlowCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxConstFlowAttribute", readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstTempCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstTempAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstTempCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMinConstTempAttribute", readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstTempCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstTempAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstTempCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.put("readEffectiveControlModeAttribute", readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlCapacityCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readCapacityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlCapacityCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); + Map readPumpConfigurationAndControlSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readSpeedAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlSpeedCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeRunningHoursAttribute( + ( ChipClusters.PumpConfigurationAndControlCluster.LifetimeRunningHoursAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlLifetimeRunningHoursCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readLifetimeRunningHoursAttribute", - readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); - Map readPumpConfigurationAndControlPowerCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readPowerAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readPumpConfigurationAndControlLifetimeRunningHoursCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readLifetimeRunningHoursAttribute", readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); + Map readPumpConfigurationAndControlPowerCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readPowerAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlPowerCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); - Map - readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readLifetimeEnergyConsumedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .LifetimeEnergyConsumedAttributeCallback) - callback); - }, + readPumpConfigurationAndControlPowerCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); + Map readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeEnergyConsumedAttribute( + ( ChipClusters.PumpConfigurationAndControlCluster.LifetimeEnergyConsumedAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.put( - "readControlModeAttribute", - readPumpConfigurationAndControlControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlAlarmMaskCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readAlarmMaskAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlAlarmMaskCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo); - Map readPumpConfigurationAndControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), - readPumpConfigurationAndControlAttributeListCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readAttributeListAttribute", - readPumpConfigurationAndControlAttributeListAttributeInteractionInfo); - Map readPumpConfigurationAndControlFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.put("readControlModeAttribute", readPumpConfigurationAndControlControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlAlarmMaskCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAlarmMaskAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlAlarmMaskCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo); + Map readPumpConfigurationAndControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAttributeListAttribute( + ( ChipClusters.PumpConfigurationAndControlCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), + readPumpConfigurationAndControlAttributeListCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.put( - "readClusterRevisionAttribute", - readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo); - Map readRelativeHumidityMeasurementInteractionInfo = - new LinkedHashMap<>(); - Map readRelativeHumidityMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMeasuredValueCommandParams); - readRelativeHumidityMeasurementInteractionInfo.put( - "readMeasuredValueAttribute", - readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMinMeasuredValueCommandParams); - readRelativeHumidityMeasurementInteractionInfo.put( - "readMinMeasuredValueAttribute", - readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMaxMeasuredValueCommandParams); - readRelativeHumidityMeasurementInteractionInfo.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); - readRelativeHumidityMeasurementInteractionInfo.put( - "readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); - Map readRelativeHumidityMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), - readRelativeHumidityMeasurementAttributeListCommandParams); - readRelativeHumidityMeasurementInteractionInfo.put( - "readAttributeListAttribute", - readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementClusterRevisionCommandParams); - readRelativeHumidityMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", - readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo); - Map readScenesInteractionInfo = new LinkedHashMap<>(); - Map readScenesSceneCountCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesSceneCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readSceneCountAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesSceneCountCommandParams); - readScenesInteractionInfo.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); - readScenesInteractionInfo.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); - readScenesInteractionInfo.put( - "readCurrentGroupAttribute", readScenesCurrentGroupAttributeInteractionInfo); - Map readScenesSceneValidCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesSceneValidAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readSceneValidAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readPumpConfigurationAndControlFeatureMapCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.put("readClusterRevisionAttribute", readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo); + Map readRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readRelativeHumidityMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMeasuredValueCommandParams + ); + readRelativeHumidityMeasurementInteractionInfo.put("readMeasuredValueAttribute", readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMinMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMinMeasuredValueCommandParams + ); + readRelativeHumidityMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMaxMeasuredValueCommandParams + ); + readRelativeHumidityMeasurementInteractionInfo.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 + ); + readRelativeHumidityMeasurementInteractionInfo.put("readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); + Map readRelativeHumidityMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.RelativeHumidityMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), + readRelativeHumidityMeasurementAttributeListCommandParams + ); + readRelativeHumidityMeasurementInteractionInfo.put("readAttributeListAttribute", readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementClusterRevisionCommandParams + ); + readRelativeHumidityMeasurementInteractionInfo.put("readClusterRevisionAttribute", readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo); + Map readScenesInteractionInfo = new LinkedHashMap<>(); + Map readScenesSceneCountCommandParams = new LinkedHashMap(); + InteractionInfo readScenesSceneCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readSceneCountAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesSceneCountCommandParams + ); + readScenesInteractionInfo.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 + ); + readScenesInteractionInfo.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 + ); + readScenesInteractionInfo.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); - readScenesInteractionInfo.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); - readScenesInteractionInfo.put( - "readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); - Map readScenesAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ScenesCluster.AttributeListAttributeCallback) callback); - }, + readScenesSceneValidCommandParams + ); + readScenesInteractionInfo.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 + ); + readScenesInteractionInfo.put("readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); + Map readScenesAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readScenesAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ScenesCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedScenesClusterAttributeListAttributeCallback(), - readScenesAttributeListCommandParams); - readScenesInteractionInfo.put( - "readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); - Map readScenesClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesClusterRevisionCommandParams); - readScenesInteractionInfo.put( - "readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("scenes", readScenesInteractionInfo); - Map readSoftwareDiagnosticsInteractionInfo = 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); - readSoftwareDiagnosticsInteractionInfo.put( - "readThreadMetricsAttribute", readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapFreeCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readCurrentHeapFreeAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readScenesAttributeListCommandParams + ); + readScenesInteractionInfo.put("readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); + Map readScenesClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesClusterRevisionCommandParams + ); + readScenesInteractionInfo.put("readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("scenes", readScenesInteractionInfo); + Map readSoftwareDiagnosticsInteractionInfo = 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 + ); + readSoftwareDiagnosticsInteractionInfo.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); - readSoftwareDiagnosticsInteractionInfo.put( - "readCurrentHeapFreeAttribute", - readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapUsedCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readCurrentHeapUsedAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readSoftwareDiagnosticsCurrentHeapFreeCommandParams + ); + readSoftwareDiagnosticsInteractionInfo.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); - readSoftwareDiagnosticsInteractionInfo.put( - "readCurrentHeapUsedAttribute", - readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readCurrentHeapHighWatermarkAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readSoftwareDiagnosticsCurrentHeapUsedCommandParams + ); + readSoftwareDiagnosticsInteractionInfo.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); - readSoftwareDiagnosticsInteractionInfo.put( - "readCurrentHeapHighWatermarkAttribute", - readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); - Map readSoftwareDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), - readSoftwareDiagnosticsAttributeListCommandParams); - readSoftwareDiagnosticsInteractionInfo.put( - "readAttributeListAttribute", readSoftwareDiagnosticsAttributeListAttributeInteractionInfo); - Map readSoftwareDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams + ); + readSoftwareDiagnosticsInteractionInfo.put("readCurrentHeapHighWatermarkAttribute", readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); + Map readSoftwareDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), + readSoftwareDiagnosticsAttributeListCommandParams + ); + readSoftwareDiagnosticsInteractionInfo.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); - readSoftwareDiagnosticsInteractionInfo.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); - readSoftwareDiagnosticsInteractionInfo.put( - "readClusterRevisionAttribute", - readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo); - Map readSwitchInteractionInfo = new LinkedHashMap<>(); - Map readSwitchNumberOfPositionsCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readNumberOfPositionsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchNumberOfPositionsCommandParams); - readSwitchInteractionInfo.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); - readSwitchInteractionInfo.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); - readSwitchInteractionInfo.put( - "readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); - Map readSwitchAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.SwitchCluster.AttributeListAttributeCallback) callback); - }, + readSoftwareDiagnosticsFeatureMapCommandParams + ); + readSoftwareDiagnosticsInteractionInfo.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 + ); + readSoftwareDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo); + Map readSwitchInteractionInfo = new LinkedHashMap<>(); + Map readSwitchNumberOfPositionsCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readNumberOfPositionsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchNumberOfPositionsCommandParams + ); + readSwitchInteractionInfo.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 + ); + readSwitchInteractionInfo.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 + ); + readSwitchInteractionInfo.put("readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); + Map readSwitchAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readAttributeListAttribute( + ( ChipClusters.SwitchCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedSwitchClusterAttributeListAttributeCallback(), - readSwitchAttributeListCommandParams); - readSwitchInteractionInfo.put( - "readAttributeListAttribute", readSwitchAttributeListAttributeInteractionInfo); - Map readSwitchFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readSwitchAttributeListCommandParams + ); + readSwitchInteractionInfo.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); - readSwitchInteractionInfo.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); - readSwitchInteractionInfo.put( - "readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("switch", readSwitchInteractionInfo); - Map readTargetNavigatorInteractionInfo = new LinkedHashMap<>(); - Map readTargetNavigatorTargetNavigatorListCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorTargetNavigatorListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readTargetNavigatorListAttribute( - (ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback(), - readTargetNavigatorTargetNavigatorListCommandParams); - readTargetNavigatorInteractionInfo.put( - "readTargetNavigatorListAttribute", - readTargetNavigatorTargetNavigatorListAttributeInteractionInfo); - Map readTargetNavigatorCurrentNavigatorTargetCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readCurrentNavigatorTargetAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorCurrentNavigatorTargetCommandParams); - readTargetNavigatorInteractionInfo.put( - "readCurrentNavigatorTargetAttribute", - readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo); - Map readTargetNavigatorAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), - readTargetNavigatorAttributeListCommandParams); - readTargetNavigatorInteractionInfo.put( - "readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); - Map readTargetNavigatorClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorClusterRevisionCommandParams); - readTargetNavigatorInteractionInfo.put( - "readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("targetNavigator", readTargetNavigatorInteractionInfo); - Map readTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readTemperatureMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMeasuredValueCommandParams); - readTemperatureMeasurementInteractionInfo.put( - "readMeasuredValueAttribute", - readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMinMeasuredValueCommandParams); - readTemperatureMeasurementInteractionInfo.put( - "readMinMeasuredValueAttribute", - readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMaxMeasuredValueCommandParams); - readTemperatureMeasurementInteractionInfo.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); - readTemperatureMeasurementInteractionInfo.put( - "readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); - Map readTemperatureMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), - readTemperatureMeasurementAttributeListCommandParams); - readTemperatureMeasurementInteractionInfo.put( - "readAttributeListAttribute", - readTemperatureMeasurementAttributeListAttributeInteractionInfo); - Map readTemperatureMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementClusterRevisionCommandParams); - readTemperatureMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", - readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo); - Map readTestClusterInteractionInfo = new LinkedHashMap<>(); - Map readTestClusterBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readSwitchFeatureMapCommandParams + ); + readSwitchInteractionInfo.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 + ); + readSwitchInteractionInfo.put("readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("switch", readSwitchInteractionInfo); + Map readTargetNavigatorInteractionInfo = new LinkedHashMap<>(); + Map readTargetNavigatorTargetNavigatorListCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorTargetNavigatorListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readTargetNavigatorListAttribute( + ( ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback(), + readTargetNavigatorTargetNavigatorListCommandParams + ); + readTargetNavigatorInteractionInfo.put("readTargetNavigatorListAttribute", readTargetNavigatorTargetNavigatorListAttributeInteractionInfo); + Map readTargetNavigatorCurrentNavigatorTargetCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readCurrentNavigatorTargetAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorCurrentNavigatorTargetCommandParams + ); + readTargetNavigatorInteractionInfo.put("readCurrentNavigatorTargetAttribute", readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo); + Map readTargetNavigatorAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readAttributeListAttribute( + ( ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), + readTargetNavigatorAttributeListCommandParams + ); + readTargetNavigatorInteractionInfo.put("readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); + Map readTargetNavigatorClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorClusterRevisionCommandParams + ); + readTargetNavigatorInteractionInfo.put("readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("targetNavigator", readTargetNavigatorInteractionInfo); + Map readTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readTemperatureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMeasuredValueCommandParams + ); + readTemperatureMeasurementInteractionInfo.put("readMeasuredValueAttribute", readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readMinMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMinMeasuredValueCommandParams + ); + readTemperatureMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMaxMeasuredValueCommandParams + ); + readTemperatureMeasurementInteractionInfo.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 + ); + readTemperatureMeasurementInteractionInfo.put("readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); + Map readTemperatureMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), + readTemperatureMeasurementAttributeListCommandParams + ); + readTemperatureMeasurementInteractionInfo.put("readAttributeListAttribute", readTemperatureMeasurementAttributeListAttributeInteractionInfo); + Map readTemperatureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementClusterRevisionCommandParams + ); + readTemperatureMeasurementInteractionInfo.put("readClusterRevisionAttribute", readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo); + Map readTestClusterInteractionInfo = new LinkedHashMap<>(); + Map readTestClusterBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readBooleanAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterBooleanCommandParams); - readTestClusterInteractionInfo.put( - "readBooleanAttribute", readTestClusterBooleanAttributeInteractionInfo); - Map readTestClusterBitmap8CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readBitmap8Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterBitmap8CommandParams); - readTestClusterInteractionInfo.put( - "readBitmap8Attribute", readTestClusterBitmap8AttributeInteractionInfo); - Map readTestClusterBitmap16CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readBitmap16Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterBitmap16CommandParams); - readTestClusterInteractionInfo.put( - "readBitmap16Attribute", readTestClusterBitmap16AttributeInteractionInfo); - Map readTestClusterBitmap32CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readBitmap32Attribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterBooleanCommandParams + ); + readTestClusterInteractionInfo.put("readBooleanAttribute", readTestClusterBooleanAttributeInteractionInfo); + Map readTestClusterBitmap8CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readBitmap8Attribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterBitmap8CommandParams + ); + readTestClusterInteractionInfo.put("readBitmap8Attribute", readTestClusterBitmap8AttributeInteractionInfo); + Map readTestClusterBitmap16CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readBitmap16Attribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterBitmap16CommandParams + ); + readTestClusterInteractionInfo.put("readBitmap16Attribute", readTestClusterBitmap16AttributeInteractionInfo); + Map readTestClusterBitmap32CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readBitmap32Attribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterBitmap32CommandParams); - readTestClusterInteractionInfo.put( - "readBitmap32Attribute", readTestClusterBitmap32AttributeInteractionInfo); - Map readTestClusterBitmap64CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readBitmap64Attribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterBitmap32CommandParams + ); + readTestClusterInteractionInfo.put("readBitmap32Attribute", readTestClusterBitmap32AttributeInteractionInfo); + Map readTestClusterBitmap64CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readBitmap64Attribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterBitmap64CommandParams); - readTestClusterInteractionInfo.put( - "readBitmap64Attribute", readTestClusterBitmap64AttributeInteractionInfo); - Map readTestClusterInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt8uAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt8uCommandParams); - readTestClusterInteractionInfo.put( - "readInt8uAttribute", readTestClusterInt8uAttributeInteractionInfo); - Map readTestClusterInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt16uAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt16uCommandParams); - readTestClusterInteractionInfo.put( - "readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); - Map readTestClusterInt24uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt24uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterBitmap64CommandParams + ); + readTestClusterInteractionInfo.put("readBitmap64Attribute", readTestClusterBitmap64AttributeInteractionInfo); + Map readTestClusterInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt8uAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt8uCommandParams + ); + readTestClusterInteractionInfo.put("readInt8uAttribute", readTestClusterInt8uAttributeInteractionInfo); + Map readTestClusterInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt16uAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt16uCommandParams + ); + readTestClusterInteractionInfo.put("readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); + Map readTestClusterInt24uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt24uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt24uCommandParams); - readTestClusterInteractionInfo.put( - "readInt24uAttribute", readTestClusterInt24uAttributeInteractionInfo); - Map readTestClusterInt32uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt32uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt24uCommandParams + ); + readTestClusterInteractionInfo.put("readInt24uAttribute", readTestClusterInt24uAttributeInteractionInfo); + Map readTestClusterInt32uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt32uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt32uCommandParams); - readTestClusterInteractionInfo.put( - "readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); - Map readTestClusterInt40uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt40uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt32uCommandParams + ); + readTestClusterInteractionInfo.put("readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); + Map readTestClusterInt40uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt40uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt40uCommandParams); - readTestClusterInteractionInfo.put( - "readInt40uAttribute", readTestClusterInt40uAttributeInteractionInfo); - Map readTestClusterInt48uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt48uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt40uCommandParams + ); + readTestClusterInteractionInfo.put("readInt40uAttribute", readTestClusterInt40uAttributeInteractionInfo); + Map readTestClusterInt48uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt48uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt48uCommandParams); - readTestClusterInteractionInfo.put( - "readInt48uAttribute", readTestClusterInt48uAttributeInteractionInfo); - Map readTestClusterInt56uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt56uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt48uCommandParams + ); + readTestClusterInteractionInfo.put("readInt48uAttribute", readTestClusterInt48uAttributeInteractionInfo); + Map readTestClusterInt56uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt56uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt56uCommandParams); - readTestClusterInteractionInfo.put( - "readInt56uAttribute", readTestClusterInt56uAttributeInteractionInfo); - Map readTestClusterInt64uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt64uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt56uCommandParams + ); + readTestClusterInteractionInfo.put("readInt56uAttribute", readTestClusterInt56uAttributeInteractionInfo); + Map readTestClusterInt64uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt64uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt64uCommandParams); - readTestClusterInteractionInfo.put( - "readInt64uAttribute", readTestClusterInt64uAttributeInteractionInfo); - Map readTestClusterInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt8sAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt8sCommandParams); - readTestClusterInteractionInfo.put( - "readInt8sAttribute", readTestClusterInt8sAttributeInteractionInfo); - Map readTestClusterInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt16sAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt16sCommandParams); - readTestClusterInteractionInfo.put( - "readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); - Map readTestClusterInt24sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt24sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt64uCommandParams + ); + readTestClusterInteractionInfo.put("readInt64uAttribute", readTestClusterInt64uAttributeInteractionInfo); + Map readTestClusterInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt8sAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt8sCommandParams + ); + readTestClusterInteractionInfo.put("readInt8sAttribute", readTestClusterInt8sAttributeInteractionInfo); + Map readTestClusterInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt16sAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt16sCommandParams + ); + readTestClusterInteractionInfo.put("readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); + Map readTestClusterInt24sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt24sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt24sCommandParams); - readTestClusterInteractionInfo.put( - "readInt24sAttribute", readTestClusterInt24sAttributeInteractionInfo); - Map readTestClusterInt32sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt32sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt24sCommandParams + ); + readTestClusterInteractionInfo.put("readInt24sAttribute", readTestClusterInt24sAttributeInteractionInfo); + Map readTestClusterInt32sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt32sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt32sCommandParams); - readTestClusterInteractionInfo.put( - "readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); - Map readTestClusterInt40sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt40sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt32sCommandParams + ); + readTestClusterInteractionInfo.put("readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); + Map readTestClusterInt40sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt40sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt40sCommandParams); - readTestClusterInteractionInfo.put( - "readInt40sAttribute", readTestClusterInt40sAttributeInteractionInfo); - Map readTestClusterInt48sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt48sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt40sCommandParams + ); + readTestClusterInteractionInfo.put("readInt40sAttribute", readTestClusterInt40sAttributeInteractionInfo); + Map readTestClusterInt48sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt48sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt48sCommandParams); - readTestClusterInteractionInfo.put( - "readInt48sAttribute", readTestClusterInt48sAttributeInteractionInfo); - Map readTestClusterInt56sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt56sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt48sCommandParams + ); + readTestClusterInteractionInfo.put("readInt48sAttribute", readTestClusterInt48sAttributeInteractionInfo); + Map readTestClusterInt56sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt56sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt56sCommandParams); - readTestClusterInteractionInfo.put( - "readInt56sAttribute", readTestClusterInt56sAttributeInteractionInfo); - Map readTestClusterInt64sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt64sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt56sCommandParams + ); + readTestClusterInteractionInfo.put("readInt56sAttribute", readTestClusterInt56sAttributeInteractionInfo); + Map readTestClusterInt64sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt64sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt64sCommandParams); - readTestClusterInteractionInfo.put( - "readInt64sAttribute", readTestClusterInt64sAttributeInteractionInfo); - Map readTestClusterEnum8CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readEnum8Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnum8CommandParams); - readTestClusterInteractionInfo.put( - "readEnum8Attribute", readTestClusterEnum8AttributeInteractionInfo); - Map readTestClusterEnum16CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readEnum16Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnum16CommandParams); - readTestClusterInteractionInfo.put( - "readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); - Map readTestClusterFloatSingleCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readFloatSingleAttribute((ChipClusters.FloatAttributeCallback) callback); - }, + readTestClusterInt64sCommandParams + ); + readTestClusterInteractionInfo.put("readInt64sAttribute", readTestClusterInt64sAttributeInteractionInfo); + Map readTestClusterEnum8CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readEnum8Attribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnum8CommandParams + ); + readTestClusterInteractionInfo.put("readEnum8Attribute", readTestClusterEnum8AttributeInteractionInfo); + Map readTestClusterEnum16CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readEnum16Attribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnum16CommandParams + ); + readTestClusterInteractionInfo.put("readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); + Map readTestClusterFloatSingleCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readFloatSingleAttribute( + ( + ChipClusters.FloatAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readTestClusterFloatSingleCommandParams); - readTestClusterInteractionInfo.put( - "readFloatSingleAttribute", readTestClusterFloatSingleAttributeInteractionInfo); - Map readTestClusterFloatDoubleCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readFloatDoubleAttribute((ChipClusters.DoubleAttributeCallback) callback); - }, + readTestClusterFloatSingleCommandParams + ); + readTestClusterInteractionInfo.put("readFloatSingleAttribute", readTestClusterFloatSingleAttributeInteractionInfo); + Map readTestClusterFloatDoubleCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readFloatDoubleAttribute( + ( + ChipClusters.DoubleAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readTestClusterFloatDoubleCommandParams); - readTestClusterInteractionInfo.put( - "readFloatDoubleAttribute", readTestClusterFloatDoubleAttributeInteractionInfo); - Map readTestClusterOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readOctetStringAttribute((ChipClusters.OctetStringAttributeCallback) callback); - }, + readTestClusterFloatDoubleCommandParams + ); + readTestClusterInteractionInfo.put("readFloatDoubleAttribute", readTestClusterFloatDoubleAttributeInteractionInfo); + Map readTestClusterOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readOctetStringAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readOctetStringAttribute", readTestClusterOctetStringAttributeInteractionInfo); - Map readTestClusterListInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterListInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readListInt8uAttribute( - (ChipClusters.TestClusterCluster.ListInt8uAttributeCallback) callback); - }, + readTestClusterOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readOctetStringAttribute", readTestClusterOctetStringAttributeInteractionInfo); + Map readTestClusterListInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterListInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readListInt8uAttribute( + ( ChipClusters.TestClusterCluster.ListInt8uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedTestClusterClusterListInt8uAttributeCallback(), - readTestClusterListInt8uCommandParams); - readTestClusterInteractionInfo.put( - "readListInt8uAttribute", readTestClusterListInt8uAttributeInteractionInfo); - Map readTestClusterListOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterListOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readListOctetStringAttribute( - (ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTestClusterClusterListOctetStringAttributeCallback(), - readTestClusterListOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readListOctetStringAttribute", readTestClusterListOctetStringAttributeInteractionInfo); - Map readTestClusterListStructOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterListStructOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readListStructOctetStringAttribute( - (ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTestClusterClusterListStructOctetStringAttributeCallback(), - readTestClusterListStructOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readListStructOctetStringAttribute", - readTestClusterListStructOctetStringAttributeInteractionInfo); - Map readTestClusterLongOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterLongOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readLongOctetStringAttribute( - (ChipClusters.OctetStringAttributeCallback) callback); - }, + readTestClusterListInt8uCommandParams + ); + readTestClusterInteractionInfo.put("readListInt8uAttribute", readTestClusterListInt8uAttributeInteractionInfo); + Map readTestClusterListOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterListOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readListOctetStringAttribute( + ( ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTestClusterClusterListOctetStringAttributeCallback(), + readTestClusterListOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readListOctetStringAttribute", readTestClusterListOctetStringAttributeInteractionInfo); + Map readTestClusterListStructOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterListStructOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readListStructOctetStringAttribute( + ( ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTestClusterClusterListStructOctetStringAttributeCallback(), + readTestClusterListStructOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readListStructOctetStringAttribute", readTestClusterListStructOctetStringAttributeInteractionInfo); + Map readTestClusterLongOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterLongOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readLongOctetStringAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterLongOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeInteractionInfo); - Map readTestClusterCharStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readTestClusterLongOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeInteractionInfo); + Map readTestClusterCharStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readCharStringAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterCharStringCommandParams); - readTestClusterInteractionInfo.put( - "readCharStringAttribute", readTestClusterCharStringAttributeInteractionInfo); - Map readTestClusterLongCharStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterLongCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readLongCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readTestClusterCharStringCommandParams + ); + readTestClusterInteractionInfo.put("readCharStringAttribute", readTestClusterCharStringAttributeInteractionInfo); + Map readTestClusterLongCharStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterLongCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readLongCharStringAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterLongCharStringCommandParams); - readTestClusterInteractionInfo.put( - "readLongCharStringAttribute", readTestClusterLongCharStringAttributeInteractionInfo); - Map readTestClusterEpochUsCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterEpochUsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readEpochUsAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterLongCharStringCommandParams + ); + readTestClusterInteractionInfo.put("readLongCharStringAttribute", readTestClusterLongCharStringAttributeInteractionInfo); + Map readTestClusterEpochUsCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterEpochUsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readEpochUsAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterEpochUsCommandParams); - readTestClusterInteractionInfo.put( - "readEpochUsAttribute", readTestClusterEpochUsAttributeInteractionInfo); - Map readTestClusterEpochSCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterEpochSAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readEpochSAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterEpochUsCommandParams + ); + readTestClusterInteractionInfo.put("readEpochUsAttribute", readTestClusterEpochUsAttributeInteractionInfo); + Map readTestClusterEpochSCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterEpochSAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readEpochSAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterEpochSCommandParams); - readTestClusterInteractionInfo.put( - "readEpochSAttribute", readTestClusterEpochSAttributeInteractionInfo); - Map readTestClusterVendorIdCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterVendorIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readVendorIdAttribute( - (ChipClusters.TestClusterCluster.VendorIdAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterVendorIdCommandParams); - readTestClusterInteractionInfo.put( - "readVendorIdAttribute", readTestClusterVendorIdAttributeInteractionInfo); - Map readTestClusterListNullablesAndOptionalsStructCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readListNullablesAndOptionalsStructAttribute( - (ChipClusters.TestClusterCluster - .ListNullablesAndOptionalsStructAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback(), - readTestClusterListNullablesAndOptionalsStructCommandParams); - readTestClusterInteractionInfo.put( - "readListNullablesAndOptionalsStructAttribute", - readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); - Map readTestClusterEnumAttrCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readEnumAttrAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnumAttrCommandParams); - readTestClusterInteractionInfo.put( - "readEnumAttrAttribute", readTestClusterEnumAttrAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readRangeRestrictedInt8uAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt8uCommandParams); - readTestClusterInteractionInfo.put( - "readRangeRestrictedInt8uAttribute", - readTestClusterRangeRestrictedInt8uAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readRangeRestrictedInt8sAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt8sCommandParams); - readTestClusterInteractionInfo.put( - "readRangeRestrictedInt8sAttribute", - readTestClusterRangeRestrictedInt8sAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readRangeRestrictedInt16uAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt16uCommandParams); - readTestClusterInteractionInfo.put( - "readRangeRestrictedInt16uAttribute", - readTestClusterRangeRestrictedInt16uAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readRangeRestrictedInt16sAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt16sCommandParams); - readTestClusterInteractionInfo.put( - "readRangeRestrictedInt16sAttribute", - readTestClusterRangeRestrictedInt16sAttributeInteractionInfo); - Map readTestClusterListLongOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterListLongOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readListLongOctetStringAttribute( - (ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTestClusterClusterListLongOctetStringAttributeCallback(), - readTestClusterListLongOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readListLongOctetStringAttribute", - readTestClusterListLongOctetStringAttributeInteractionInfo); - Map readTestClusterTimedWriteBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterTimedWriteBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readTimedWriteBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readTestClusterEpochSCommandParams + ); + readTestClusterInteractionInfo.put("readEpochSAttribute", readTestClusterEpochSAttributeInteractionInfo); + Map readTestClusterVendorIdCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterVendorIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readVendorIdAttribute( + ( ChipClusters.TestClusterCluster.VendorIdAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterVendorIdCommandParams + ); + readTestClusterInteractionInfo.put("readVendorIdAttribute", readTestClusterVendorIdAttributeInteractionInfo); + Map readTestClusterListNullablesAndOptionalsStructCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readListNullablesAndOptionalsStructAttribute( + ( ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback(), + readTestClusterListNullablesAndOptionalsStructCommandParams + ); + readTestClusterInteractionInfo.put("readListNullablesAndOptionalsStructAttribute", readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); + Map readTestClusterEnumAttrCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readEnumAttrAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnumAttrCommandParams + ); + readTestClusterInteractionInfo.put("readEnumAttrAttribute", readTestClusterEnumAttrAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt8uAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8uCommandParams + ); + readTestClusterInteractionInfo.put("readRangeRestrictedInt8uAttribute", readTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt8sAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8sCommandParams + ); + readTestClusterInteractionInfo.put("readRangeRestrictedInt8sAttribute", readTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt16uAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16uCommandParams + ); + readTestClusterInteractionInfo.put("readRangeRestrictedInt16uAttribute", readTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt16sAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16sCommandParams + ); + readTestClusterInteractionInfo.put("readRangeRestrictedInt16sAttribute", readTestClusterRangeRestrictedInt16sAttributeInteractionInfo); + Map readTestClusterListLongOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterListLongOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readListLongOctetStringAttribute( + ( ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTestClusterClusterListLongOctetStringAttributeCallback(), + readTestClusterListLongOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readListLongOctetStringAttribute", readTestClusterListLongOctetStringAttributeInteractionInfo); + Map readTestClusterTimedWriteBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readTimedWriteBooleanAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterTimedWriteBooleanCommandParams); - readTestClusterInteractionInfo.put( - "readTimedWriteBooleanAttribute", readTestClusterTimedWriteBooleanAttributeInteractionInfo); - Map readTestClusterGeneralErrorBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterGeneralErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readGeneralErrorBooleanAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readTestClusterTimedWriteBooleanCommandParams + ); + readTestClusterInteractionInfo.put("readTimedWriteBooleanAttribute", readTestClusterTimedWriteBooleanAttributeInteractionInfo); + Map readTestClusterGeneralErrorBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readGeneralErrorBooleanAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterGeneralErrorBooleanCommandParams); - readTestClusterInteractionInfo.put( - "readGeneralErrorBooleanAttribute", - readTestClusterGeneralErrorBooleanAttributeInteractionInfo); - Map readTestClusterClusterErrorBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterClusterErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readClusterErrorBooleanAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readTestClusterGeneralErrorBooleanCommandParams + ); + readTestClusterInteractionInfo.put("readGeneralErrorBooleanAttribute", readTestClusterGeneralErrorBooleanAttributeInteractionInfo); + Map readTestClusterClusterErrorBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readClusterErrorBooleanAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterClusterErrorBooleanCommandParams); - readTestClusterInteractionInfo.put( - "readClusterErrorBooleanAttribute", - readTestClusterClusterErrorBooleanAttributeInteractionInfo); - Map readTestClusterUnsupportedCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readUnsupportedAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readTestClusterClusterErrorBooleanCommandParams + ); + readTestClusterInteractionInfo.put("readClusterErrorBooleanAttribute", readTestClusterClusterErrorBooleanAttributeInteractionInfo); + Map readTestClusterUnsupportedCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readUnsupportedAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterUnsupportedCommandParams); - readTestClusterInteractionInfo.put( - "readUnsupportedAttribute", readTestClusterUnsupportedAttributeInteractionInfo); - Map readTestClusterNullableBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableBooleanAttribute( - (ChipClusters.TestClusterCluster.NullableBooleanAttributeCallback) callback); - }, + readTestClusterUnsupportedCommandParams + ); + readTestClusterInteractionInfo.put("readUnsupportedAttribute", readTestClusterUnsupportedAttributeInteractionInfo); + Map readTestClusterNullableBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableBooleanAttribute( + ( ChipClusters.TestClusterCluster.NullableBooleanAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterNullableBooleanCommandParams); - readTestClusterInteractionInfo.put( - "readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeInteractionInfo); - Map readTestClusterNullableBitmap8CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableBitmap8Attribute( - (ChipClusters.TestClusterCluster.NullableBitmap8AttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableBitmap8CommandParams); - readTestClusterInteractionInfo.put( - "readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeInteractionInfo); - Map readTestClusterNullableBitmap16CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableBitmap16Attribute( - (ChipClusters.TestClusterCluster.NullableBitmap16AttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableBitmap16CommandParams); - readTestClusterInteractionInfo.put( - "readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeInteractionInfo); - Map readTestClusterNullableBitmap32CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableBitmap32Attribute( - (ChipClusters.TestClusterCluster.NullableBitmap32AttributeCallback) callback); - }, + readTestClusterNullableBooleanCommandParams + ); + readTestClusterInteractionInfo.put("readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeInteractionInfo); + Map readTestClusterNullableBitmap8CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap8Attribute( + ( ChipClusters.TestClusterCluster.NullableBitmap8AttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableBitmap8CommandParams + ); + readTestClusterInteractionInfo.put("readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeInteractionInfo); + Map readTestClusterNullableBitmap16CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap16Attribute( + ( ChipClusters.TestClusterCluster.NullableBitmap16AttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableBitmap16CommandParams + ); + readTestClusterInteractionInfo.put("readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeInteractionInfo); + Map readTestClusterNullableBitmap32CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap32Attribute( + ( ChipClusters.TestClusterCluster.NullableBitmap32AttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableBitmap32CommandParams); - readTestClusterInteractionInfo.put( - "readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeInteractionInfo); - Map readTestClusterNullableBitmap64CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableBitmap64Attribute( - (ChipClusters.TestClusterCluster.NullableBitmap64AttributeCallback) callback); - }, + readTestClusterNullableBitmap32CommandParams + ); + readTestClusterInteractionInfo.put("readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeInteractionInfo); + Map readTestClusterNullableBitmap64CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap64Attribute( + ( ChipClusters.TestClusterCluster.NullableBitmap64AttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableBitmap64CommandParams); - readTestClusterInteractionInfo.put( - "readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeInteractionInfo); - Map readTestClusterNullableInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt8uAttribute( - (ChipClusters.TestClusterCluster.NullableInt8uAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt8uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeInteractionInfo); - Map readTestClusterNullableInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt16uAttribute( - (ChipClusters.TestClusterCluster.NullableInt16uAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt16uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); - Map readTestClusterNullableInt24uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt24uAttribute( - (ChipClusters.TestClusterCluster.NullableInt24uAttributeCallback) callback); - }, + readTestClusterNullableBitmap64CommandParams + ); + readTestClusterInteractionInfo.put("readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeInteractionInfo); + Map readTestClusterNullableInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt8uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt8uAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt8uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeInteractionInfo); + Map readTestClusterNullableInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt16uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt16uAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt16uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); + Map readTestClusterNullableInt24uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt24uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt24uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt24uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt24uAttribute", readTestClusterNullableInt24uAttributeInteractionInfo); - Map readTestClusterNullableInt32uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt32uAttribute( - (ChipClusters.TestClusterCluster.NullableInt32uAttributeCallback) callback); - }, + readTestClusterNullableInt24uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt24uAttribute", readTestClusterNullableInt24uAttributeInteractionInfo); + Map readTestClusterNullableInt32uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt32uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt32uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt32uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); - Map readTestClusterNullableInt40uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt40uAttribute( - (ChipClusters.TestClusterCluster.NullableInt40uAttributeCallback) callback); - }, + readTestClusterNullableInt32uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); + Map readTestClusterNullableInt40uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt40uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt40uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt40uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt40uAttribute", readTestClusterNullableInt40uAttributeInteractionInfo); - Map readTestClusterNullableInt48uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt48uAttribute( - (ChipClusters.TestClusterCluster.NullableInt48uAttributeCallback) callback); - }, + readTestClusterNullableInt40uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt40uAttribute", readTestClusterNullableInt40uAttributeInteractionInfo); + Map readTestClusterNullableInt48uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt48uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt48uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt48uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt48uAttribute", readTestClusterNullableInt48uAttributeInteractionInfo); - Map readTestClusterNullableInt56uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt56uAttribute( - (ChipClusters.TestClusterCluster.NullableInt56uAttributeCallback) callback); - }, + readTestClusterNullableInt48uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt48uAttribute", readTestClusterNullableInt48uAttributeInteractionInfo); + Map readTestClusterNullableInt56uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt56uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt56uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt56uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt56uAttribute", readTestClusterNullableInt56uAttributeInteractionInfo); - Map readTestClusterNullableInt64uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt64uAttribute( - (ChipClusters.TestClusterCluster.NullableInt64uAttributeCallback) callback); - }, + readTestClusterNullableInt56uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt56uAttribute", readTestClusterNullableInt56uAttributeInteractionInfo); + Map readTestClusterNullableInt64uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt64uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt64uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt64uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeInteractionInfo); - Map readTestClusterNullableInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt8sAttribute( - (ChipClusters.TestClusterCluster.NullableInt8sAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt8sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeInteractionInfo); - Map readTestClusterNullableInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt16sAttribute( - (ChipClusters.TestClusterCluster.NullableInt16sAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt16sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); - Map readTestClusterNullableInt24sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt24sAttribute( - (ChipClusters.TestClusterCluster.NullableInt24sAttributeCallback) callback); - }, + readTestClusterNullableInt64uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeInteractionInfo); + Map readTestClusterNullableInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt8sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt8sAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt8sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeInteractionInfo); + Map readTestClusterNullableInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt16sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt16sAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt16sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); + Map readTestClusterNullableInt24sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt24sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt24sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt24sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt24sAttribute", readTestClusterNullableInt24sAttributeInteractionInfo); - Map readTestClusterNullableInt32sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt32sAttribute( - (ChipClusters.TestClusterCluster.NullableInt32sAttributeCallback) callback); - }, + readTestClusterNullableInt24sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt24sAttribute", readTestClusterNullableInt24sAttributeInteractionInfo); + Map readTestClusterNullableInt32sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt32sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt32sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt32sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); - Map readTestClusterNullableInt40sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt40sAttribute( - (ChipClusters.TestClusterCluster.NullableInt40sAttributeCallback) callback); - }, + readTestClusterNullableInt32sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); + Map readTestClusterNullableInt40sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt40sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt40sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt40sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt40sAttribute", readTestClusterNullableInt40sAttributeInteractionInfo); - Map readTestClusterNullableInt48sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt48sAttribute( - (ChipClusters.TestClusterCluster.NullableInt48sAttributeCallback) callback); - }, + readTestClusterNullableInt40sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt40sAttribute", readTestClusterNullableInt40sAttributeInteractionInfo); + Map readTestClusterNullableInt48sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt48sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt48sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt48sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt48sAttribute", readTestClusterNullableInt48sAttributeInteractionInfo); - Map readTestClusterNullableInt56sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt56sAttribute( - (ChipClusters.TestClusterCluster.NullableInt56sAttributeCallback) callback); - }, + readTestClusterNullableInt48sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt48sAttribute", readTestClusterNullableInt48sAttributeInteractionInfo); + Map readTestClusterNullableInt56sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt56sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt56sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt56sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt56sAttribute", readTestClusterNullableInt56sAttributeInteractionInfo); - Map readTestClusterNullableInt64sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt64sAttribute( - (ChipClusters.TestClusterCluster.NullableInt64sAttributeCallback) callback); - }, + readTestClusterNullableInt56sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt56sAttribute", readTestClusterNullableInt56sAttributeInteractionInfo); + Map readTestClusterNullableInt64sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt64sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt64sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt64sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeInteractionInfo); - Map readTestClusterNullableEnum8CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableEnum8Attribute( - (ChipClusters.TestClusterCluster.NullableEnum8AttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnum8CommandParams); - readTestClusterInteractionInfo.put( - "readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeInteractionInfo); - Map readTestClusterNullableEnum16CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableEnum16Attribute( - (ChipClusters.TestClusterCluster.NullableEnum16AttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnum16CommandParams); - readTestClusterInteractionInfo.put( - "readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); - Map readTestClusterNullableFloatSingleCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableFloatSingleAttribute( - (ChipClusters.TestClusterCluster.NullableFloatSingleAttributeCallback) - callback); - }, + readTestClusterNullableInt64sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeInteractionInfo); + Map readTestClusterNullableEnum8CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableEnum8Attribute( + ( ChipClusters.TestClusterCluster.NullableEnum8AttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnum8CommandParams + ); + readTestClusterInteractionInfo.put("readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeInteractionInfo); + Map readTestClusterNullableEnum16CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableEnum16Attribute( + ( ChipClusters.TestClusterCluster.NullableEnum16AttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnum16CommandParams + ); + readTestClusterInteractionInfo.put("readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); + Map readTestClusterNullableFloatSingleCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableFloatSingleAttribute( + ( ChipClusters.TestClusterCluster.NullableFloatSingleAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readTestClusterNullableFloatSingleCommandParams); - readTestClusterInteractionInfo.put( - "readNullableFloatSingleAttribute", - readTestClusterNullableFloatSingleAttributeInteractionInfo); - Map readTestClusterNullableFloatDoubleCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableFloatDoubleAttribute( - (ChipClusters.TestClusterCluster.NullableFloatDoubleAttributeCallback) - callback); - }, + readTestClusterNullableFloatSingleCommandParams + ); + readTestClusterInteractionInfo.put("readNullableFloatSingleAttribute", readTestClusterNullableFloatSingleAttributeInteractionInfo); + Map readTestClusterNullableFloatDoubleCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableFloatDoubleAttribute( + ( ChipClusters.TestClusterCluster.NullableFloatDoubleAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readTestClusterNullableFloatDoubleCommandParams); - readTestClusterInteractionInfo.put( - "readNullableFloatDoubleAttribute", - readTestClusterNullableFloatDoubleAttributeInteractionInfo); - Map readTestClusterNullableOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableOctetStringAttribute( - (ChipClusters.TestClusterCluster.NullableOctetStringAttributeCallback) - callback); - }, + readTestClusterNullableFloatDoubleCommandParams + ); + readTestClusterInteractionInfo.put("readNullableFloatDoubleAttribute", readTestClusterNullableFloatDoubleAttributeInteractionInfo); + Map readTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableOctetStringAttribute( + ( ChipClusters.TestClusterCluster.NullableOctetStringAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterNullableOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readNullableOctetStringAttribute", - readTestClusterNullableOctetStringAttributeInteractionInfo); - Map readTestClusterNullableCharStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableCharStringAttribute( - (ChipClusters.TestClusterCluster.NullableCharStringAttributeCallback) - callback); - }, + readTestClusterNullableOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readNullableOctetStringAttribute", readTestClusterNullableOctetStringAttributeInteractionInfo); + Map readTestClusterNullableCharStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableCharStringAttribute( + ( ChipClusters.TestClusterCluster.NullableCharStringAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterNullableCharStringCommandParams); - readTestClusterInteractionInfo.put( - "readNullableCharStringAttribute", - readTestClusterNullableCharStringAttributeInteractionInfo); - Map readTestClusterNullableEnumAttrCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableEnumAttrAttribute( - (ChipClusters.TestClusterCluster.NullableEnumAttrAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnumAttrCommandParams); - readTestClusterInteractionInfo.put( - "readNullableEnumAttrAttribute", readTestClusterNullableEnumAttrAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableRangeRestrictedInt8uAttribute( - (ChipClusters.TestClusterCluster - .NullableRangeRestrictedInt8uAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt8uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableRangeRestrictedInt8uAttribute", - readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableRangeRestrictedInt8sAttribute( - (ChipClusters.TestClusterCluster - .NullableRangeRestrictedInt8sAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt8sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableRangeRestrictedInt8sAttribute", - readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableRangeRestrictedInt16uAttribute( - (ChipClusters.TestClusterCluster - .NullableRangeRestrictedInt16uAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt16uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableRangeRestrictedInt16uAttribute", - readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableRangeRestrictedInt16sAttribute( - (ChipClusters.TestClusterCluster - .NullableRangeRestrictedInt16sAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt16sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableRangeRestrictedInt16sAttribute", - readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); - Map readTestClusterAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TestClusterCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedTestClusterClusterAttributeListAttributeCallback(), - readTestClusterAttributeListCommandParams); - readTestClusterInteractionInfo.put( - "readAttributeListAttribute", readTestClusterAttributeListAttributeInteractionInfo); - Map readTestClusterClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterClusterRevisionCommandParams); - readTestClusterInteractionInfo.put( - "readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("testCluster", readTestClusterInteractionInfo); - Map readThermostatInteractionInfo = new LinkedHashMap<>(); - Map readThermostatLocalTemperatureCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readLocalTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatLocalTemperatureCommandParams); - readThermostatInteractionInfo.put( - "readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); - Map readThermostatAbsMinHeatSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readAbsMinHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMinHeatSetpointLimitCommandParams); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readAbsMaxCoolSetpointLimitAttribute", - readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatOccupiedCoolingSetpointCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readOccupiedCoolingSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatOccupiedCoolingSetpointCommandParams); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readOccupiedHeatingSetpointAttribute", - readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); - Map readThermostatMinHeatSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readMinHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMinHeatSetpointLimitCommandParams); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readMinSetpointDeadBandAttribute", - readThermostatMinSetpointDeadBandAttributeInteractionInfo); - Map readThermostatControlSequenceOfOperationCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readControlSequenceOfOperationAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatControlSequenceOfOperationCommandParams); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); - Map readThermostatStartOfWeekCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readStartOfWeekAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatStartOfWeekCommandParams); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readNumberOfDailyTransitionsAttribute", - readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); - Map readThermostatAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ThermostatCluster.AttributeListAttributeCallback) callback); - }, + readTestClusterNullableCharStringCommandParams + ); + readTestClusterInteractionInfo.put("readNullableCharStringAttribute", readTestClusterNullableCharStringAttributeInteractionInfo); + Map readTestClusterNullableEnumAttrCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableEnumAttrAttribute( + ( ChipClusters.TestClusterCluster.NullableEnumAttrAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnumAttrCommandParams + ); + readTestClusterInteractionInfo.put("readNullableEnumAttrAttribute", readTestClusterNullableEnumAttrAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt8uAttribute( + ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt8uAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt8uAttribute", readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt8sAttribute( + ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt8sAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt8sAttribute", readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt16uAttribute( + ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt16uAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt16uAttribute", readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt16sAttribute( + ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt16sAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt16sAttribute", readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); + Map readTestClusterAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readAttributeListAttribute( + ( ChipClusters.TestClusterCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTestClusterClusterAttributeListAttributeCallback(), + readTestClusterAttributeListCommandParams + ); + readTestClusterInteractionInfo.put("readAttributeListAttribute", readTestClusterAttributeListAttributeInteractionInfo); + Map readTestClusterClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterClusterRevisionCommandParams + ); + readTestClusterInteractionInfo.put("readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("testCluster", readTestClusterInteractionInfo); + Map readThermostatInteractionInfo = new LinkedHashMap<>(); + Map readThermostatLocalTemperatureCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readLocalTemperatureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatLocalTemperatureCommandParams + ); + readThermostatInteractionInfo.put("readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); + Map readThermostatAbsMinHeatSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readAbsMinHeatSetpointLimitAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMinHeatSetpointLimitCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readAbsMaxCoolSetpointLimitAttribute", readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readOccupiedCoolingSetpointAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatOccupiedCoolingSetpointCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readOccupiedHeatingSetpointAttribute", readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); + Map readThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readMinHeatSetpointLimitAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMinHeatSetpointLimitCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readMinSetpointDeadBandAttribute", readThermostatMinSetpointDeadBandAttributeInteractionInfo); + Map readThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readControlSequenceOfOperationAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatControlSequenceOfOperationCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); + Map readThermostatStartOfWeekCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readStartOfWeekAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatStartOfWeekCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readNumberOfDailyTransitionsAttribute", readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); + Map readThermostatAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ThermostatCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedThermostatClusterAttributeListAttributeCallback(), - readThermostatAttributeListCommandParams); - readThermostatInteractionInfo.put( - "readAttributeListAttribute", readThermostatAttributeListAttributeInteractionInfo); - Map readThermostatFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThermostatAttributeListCommandParams + ); + readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("thermostat", readThermostatInteractionInfo); - Map readThermostatUserInterfaceConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map - readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = - new LinkedHashMap(); - InteractionInfo - readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readTemperatureDisplayModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams); - readThermostatUserInterfaceConfigurationInteractionInfo.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); - readThermostatUserInterfaceConfigurationInteractionInfo.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); - readThermostatUserInterfaceConfigurationInteractionInfo.put( - "readScheduleProgrammingVisibilityAttribute", - readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ThermostatUserInterfaceConfigurationCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), - readThermostatUserInterfaceConfigurationAttributeListCommandParams); - readThermostatUserInterfaceConfigurationInteractionInfo.put( - "readAttributeListAttribute", - readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo - readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationClusterRevisionCommandParams); - readThermostatUserInterfaceConfigurationInteractionInfo.put( - "readClusterRevisionAttribute", - readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "thermostatUserInterfaceConfiguration", - readThermostatUserInterfaceConfigurationInteractionInfo); - Map readThreadNetworkDiagnosticsInteractionInfo = - new LinkedHashMap<>(); - Map readThreadNetworkDiagnosticsChannelCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readChannelAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsChannelCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRoutingRoleAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsRoutingRoleCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRoutingRoleAttribute", - readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNetworkNameCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readNetworkNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readThermostatFeatureMapCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("thermostat", readThermostatInteractionInfo); + Map readThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); + Map readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readTemperatureDisplayModeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams + ); + readThermostatUserInterfaceConfigurationInteractionInfo.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 + ); + readThermostatUserInterfaceConfigurationInteractionInfo.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 + ); + readThermostatUserInterfaceConfigurationInteractionInfo.put("readScheduleProgrammingVisibilityAttribute", readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ThermostatUserInterfaceConfigurationCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), + readThermostatUserInterfaceConfigurationAttributeListCommandParams + ); + readThermostatUserInterfaceConfigurationInteractionInfo.put("readAttributeListAttribute", readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams + ); + readThermostatUserInterfaceConfigurationInteractionInfo.put("readClusterRevisionAttribute", readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("thermostatUserInterfaceConfiguration", readThermostatUserInterfaceConfigurationInteractionInfo); + Map readThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + Map readThreadNetworkDiagnosticsChannelCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsChannelCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRoutingRoleAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsRoutingRoleCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRoutingRoleAttribute", readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNetworkNameCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNetworkNameAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readThreadNetworkDiagnosticsNetworkNameCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readNetworkNameAttribute", - readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPanIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readPanIdAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsPanIdCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readExtendedPanIdAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsNetworkNameCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readNetworkNameAttribute", readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPanIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPanIdAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsPanIdCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readExtendedPanIdAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsExtendedPanIdCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readExtendedPanIdAttribute", - readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readMeshLocalPrefixAttribute( - (ChipClusters.OctetStringAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsExtendedPanIdCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readExtendedPanIdAttribute", readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readMeshLocalPrefixAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readMeshLocalPrefixAttribute", - readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsOverrunCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readOverrunCountAttribute", - readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNeighborTableListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readNeighborTableListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .NeighborTableListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback(), - readThreadNetworkDiagnosticsNeighborTableListCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readNeighborTableListAttribute", - readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRouteTableListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRouteTableListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback(), - readThreadNetworkDiagnosticsRouteTableListCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRouteTableListAttribute", - readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPartitionIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readPartitionIdAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsOverrunCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNeighborTableListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNeighborTableListAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback(), + readThreadNetworkDiagnosticsNeighborTableListCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readNeighborTableListAttribute", readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRouteTableListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRouteTableListAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback(), + readThreadNetworkDiagnosticsRouteTableListCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRouteTableListAttribute", readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPartitionIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPartitionIdAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsPartitionIdCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readPartitionIdAttribute", - readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsWeightingCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readWeightingAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsWeightingCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDataVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsDataVersionCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readDataVersionAttribute", - readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readStableDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsStableDataVersionCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readStableDataVersionAttribute", - readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readLeaderRouterIdAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsLeaderRouterIdCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readParentChangeCountAttribute", - readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxTotalCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsPartitionIdCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readPartitionIdAttribute", readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsWeightingCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readWeightingAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsWeightingCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDataVersionCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDataVersionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsDataVersionCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readDataVersionAttribute", readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readStableDataVersionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsStableDataVersionCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readStableDataVersionAttribute", readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readLeaderRouterIdAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsLeaderRouterIdCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxTotalCountAttribute", - readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxUnicastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxTotalCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxUnicastCountAttribute", - readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBroadcastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxUnicastCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxBroadcastCountAttribute", - readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxAckRequestedCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxBroadcastCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxAckRequestedCountAttribute", - readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxAckedCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxAckedCountAttribute", - readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxNoAckRequestedCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxAckedCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxNoAckRequestedCountAttribute", - readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxDataCountAttribute", - readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataPollCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxDataCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxDataPollCountAttribute", - readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBeaconCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxDataPollCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxBeaconCountAttribute", - readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxBeaconCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxBeaconRequestCountAttribute", - readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxOtherCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxOtherCountAttribute", - readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxRetryCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxRetryCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxOtherCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxIndirectMaxRetryExpiryCountAttribute", - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxErrCcaCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxRetryCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxRetryCountAttribute", readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDirectMaxRetryExpiryCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrCcaCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxErrCcaCountAttribute", - readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxErrAbortCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxDirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxIndirectMaxRetryExpiryCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrAbortCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxErrAbortCountAttribute", - readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxErrBusyChannelCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxIndirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrCcaCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxErrBusyChannelCountAttribute", - readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxErrCcaCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrCcaCountAttribute", readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrAbortCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxTotalCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxTotalCountAttribute", - readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxErrAbortCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrAbortCountAttribute", readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrBusyChannelCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxUnicastCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxUnicastCountAttribute", - readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrBusyChannelCountAttribute", readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxTotalCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBroadcastCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxBroadcastCountAttribute", - readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxTotalCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxTotalCountAttribute", readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxUnicastCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxDataCountAttribute", - readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxUnicastCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxUnicastCountAttribute", readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBroadcastCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataPollCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxDataPollCountAttribute", - readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxBroadcastCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxBroadcastCountAttribute", readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxBeaconCountAttribute", - readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxDataCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxDataCountAttribute", readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataPollCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxBeaconRequestCountAttribute", - readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxDataPollCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxDataPollCountAttribute", readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxOtherCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxOtherCountAttribute", - readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxAddressFilteredCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxBeaconCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxBeaconCountAttribute", readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconRequestCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxAddressFilteredCountAttribute", - readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDestAddrFilteredCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxOtherCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxDestAddrFilteredCountAttribute", - readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDuplicatedCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxOtherCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxOtherCountAttribute", readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxAddressFilteredCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxDuplicatedCountAttribute", - readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrNoFrameCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxAddressFilteredCountAttribute", readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDestAddrFilteredCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrNoFrameCountAttribute", - readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrUnknownNeighborCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxDestAddrFilteredCountAttribute", readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDuplicatedCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrUnknownNeighborCountAttribute", - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrInvalidSrcAddrCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxDuplicatedCountAttribute", readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrNoFrameCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrInvalidSrcAddrCountAttribute", - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrSecCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrNoFrameCountAttribute", readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrUnknownNeighborCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrSecCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrSecCountAttribute", - readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrFcsCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrUnknownNeighborCountAttribute", readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrInvalidSrcAddrCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrFcsCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrFcsCountAttribute", - readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrInvalidSrcAddrCountAttribute", readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrSecCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrOtherCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrOtherCountAttribute", - readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readActiveTimestampAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrSecCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrSecCountAttribute", readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrFcsCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsActiveTimestampCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readActiveTimestampAttribute", - readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readPendingTimestampAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrFcsCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrFcsCountAttribute", readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrOtherCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsPendingTimestampCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readPendingTimestampAttribute", - readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDelayCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readDelayAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrOtherCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrOtherCountAttribute", readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveTimestampAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsDelayCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsSecurityPolicyCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readSecurityPolicyAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback(), - readThreadNetworkDiagnosticsSecurityPolicyCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readSecurityPolicyAttribute", - readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsChannelMaskCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readChannelMaskAttribute((ChipClusters.OctetStringAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsActiveTimestampCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readActiveTimestampAttribute", readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPendingTimestampAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsPendingTimestampCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readPendingTimestampAttribute", readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDelayCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDelayAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsDelayCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsSecurityPolicyCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readSecurityPolicyAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback(), + readThreadNetworkDiagnosticsSecurityPolicyCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readSecurityPolicyAttribute", readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsChannelMaskCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelMaskAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readThreadNetworkDiagnosticsChannelMaskCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readChannelMaskAttribute", - readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams = - new LinkedHashMap(); - InteractionInfo - readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readOperationalDatasetComponentsAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .OperationalDatasetComponentsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback(), - readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readOperationalDatasetComponentsAttribute", - readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readActiveNetworkFaultsListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .ActiveNetworkFaultsListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), - readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readActiveNetworkFaultsListAttribute", - readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readThreadNetworkDiagnosticsAttributeListCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readAttributeListAttribute", - readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsChannelMaskCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readChannelMaskAttribute", readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readOperationalDatasetComponentsAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.OperationalDatasetComponentsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback(), + readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readOperationalDatasetComponentsAttribute", readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveNetworkFaultsListAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), + readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readActiveNetworkFaultsListAttribute", readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readThreadNetworkDiagnosticsAttributeListCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readClusterRevisionAttribute", - readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo); - Map readTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map readTimeFormatLocalizationHourFormatCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readHourFormatAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationHourFormatCommandParams); - readTimeFormatLocalizationInteractionInfo.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); - readTimeFormatLocalizationInteractionInfo.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); - readTimeFormatLocalizationInteractionInfo.put( - "readSupportedCalendarTypesAttribute", - readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); - Map readTimeFormatLocalizationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationClusterRevisionCommandParams); - readTimeFormatLocalizationInteractionInfo.put( - "readClusterRevisionAttribute", - readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo); - Map readUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map readUnitLocalizationTemperatureUnitCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .readTemperatureUnitAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitLocalizationTemperatureUnitCommandParams); - readUnitLocalizationInteractionInfo.put( - "readTemperatureUnitAttribute", - readUnitLocalizationTemperatureUnitAttributeInteractionInfo); - Map readUnitLocalizationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsFeatureMapCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo); + Map readTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); + Map readTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readHourFormatAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationHourFormatCommandParams + ); + readTimeFormatLocalizationInteractionInfo.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 + ); + readTimeFormatLocalizationInteractionInfo.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 + ); + readTimeFormatLocalizationInteractionInfo.put("readSupportedCalendarTypesAttribute", readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); + Map readTimeFormatLocalizationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationClusterRevisionCommandParams + ); + readTimeFormatLocalizationInteractionInfo.put("readClusterRevisionAttribute", readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo); + Map readUnitLocalizationInteractionInfo = new LinkedHashMap<>(); + Map readUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); + InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).readTemperatureUnitAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitLocalizationTemperatureUnitCommandParams + ); + readUnitLocalizationInteractionInfo.put("readTemperatureUnitAttribute", readUnitLocalizationTemperatureUnitAttributeInteractionInfo); + Map readUnitLocalizationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).readFeatureMapAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitLocalizationFeatureMapCommandParams); - readUnitLocalizationInteractionInfo.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); - readUnitLocalizationInteractionInfo.put( - "readClusterRevisionAttribute", - readUnitLocalizationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("unitLocalization", readUnitLocalizationInteractionInfo); - Map readUserLabelInteractionInfo = new LinkedHashMap<>(); - Map readUserLabelLabelListCommandParams = - new LinkedHashMap(); - InteractionInfo readUserLabelLabelListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster) - .readLabelListAttribute( - (ChipClusters.UserLabelCluster.LabelListAttributeCallback) callback); - }, + readUnitLocalizationFeatureMapCommandParams + ); + readUnitLocalizationInteractionInfo.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 + ); + readUnitLocalizationInteractionInfo.put("readClusterRevisionAttribute", readUnitLocalizationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("unitLocalization", readUnitLocalizationInteractionInfo); + Map readUserLabelInteractionInfo = 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); - readUserLabelInteractionInfo.put( - "readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); - Map readUserLabelClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUserLabelClusterRevisionCommandParams); - readUserLabelInteractionInfo.put( - "readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("userLabel", readUserLabelInteractionInfo); - Map readWakeOnLanInteractionInfo = new LinkedHashMap<>(); - Map readWakeOnLanWakeOnLanMacAddressCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readWakeOnLanMacAddressAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readUserLabelLabelListCommandParams + ); + readUserLabelInteractionInfo.put("readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); + Map readUserLabelClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUserLabelClusterRevisionCommandParams + ); + readUserLabelInteractionInfo.put("readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("userLabel", readUserLabelInteractionInfo); + Map readWakeOnLanInteractionInfo = new LinkedHashMap<>(); + Map readWakeOnLanWakeOnLanMacAddressCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readWakeOnLanMacAddressAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readWakeOnLanWakeOnLanMacAddressCommandParams); - readWakeOnLanInteractionInfo.put( - "readWakeOnLanMacAddressAttribute", - readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo); - Map readWakeOnLanAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback) callback); - }, + readWakeOnLanWakeOnLanMacAddressCommandParams + ); + readWakeOnLanInteractionInfo.put("readWakeOnLanMacAddressAttribute", readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo); + Map readWakeOnLanAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readAttributeListAttribute( + ( ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterAttributeListAttributeCallback(), - readWakeOnLanAttributeListCommandParams); - readWakeOnLanInteractionInfo.put( - "readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); - Map readWakeOnLanClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWakeOnLanClusterRevisionCommandParams); - readWakeOnLanInteractionInfo.put( - "readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("wakeOnLan", readWakeOnLanInteractionInfo); - Map readWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - Map readWiFiNetworkDiagnosticsBssidCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readBssidAttribute((ChipClusters.OctetStringAttributeCallback) callback); - }, + readWakeOnLanAttributeListCommandParams + ); + readWakeOnLanInteractionInfo.put("readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); + Map readWakeOnLanClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWakeOnLanClusterRevisionCommandParams + ); + readWakeOnLanInteractionInfo.put("readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wakeOnLan", readWakeOnLanInteractionInfo); + Map readWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + Map readWiFiNetworkDiagnosticsBssidCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBssidAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readWiFiNetworkDiagnosticsBssidCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readSecurityTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsSecurityTypeCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readSecurityTypeAttribute", - readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readWiFiVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsWiFiVersionCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readChannelNumberAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsChannelNumberCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readChannelNumberAttribute", - readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsRssiCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readRssiAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsRssiCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readBeaconLostCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsBssidCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readSecurityTypeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsSecurityTypeCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readSecurityTypeAttribute", readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readWiFiVersionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsWiFiVersionCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readChannelNumberAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsChannelNumberCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readChannelNumberAttribute", readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsRssiCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readRssiAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsRssiCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconLostCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconLostCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readBeaconLostCountAttribute", - readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readBeaconRxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsBeaconLostCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readBeaconLostCountAttribute", readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconRxCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconRxCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readBeaconRxCountAttribute", - readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); - Map - readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketMulticastRxCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsBeaconRxCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readBeaconRxCountAttribute", readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastRxCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readPacketMulticastRxCountAttribute", - readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); - Map - readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketMulticastTxCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketMulticastRxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastTxCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readPacketMulticastTxCountAttribute", - readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketUnicastRxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketMulticastTxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastRxCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readPacketUnicastRxCountAttribute", - readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketUnicastTxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketUnicastRxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastTxCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readPacketUnicastTxCountAttribute", - readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readCurrentMaxRateAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketUnicastTxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readCurrentMaxRateAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readCurrentMaxRateAttribute", - readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readCurrentMaxRateAttribute", readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsOverrunCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readOverrunCountAttribute", - readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readWiFiNetworkDiagnosticsAttributeListCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readAttributeListAttribute", - readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsOverrunCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readWiFiNetworkDiagnosticsAttributeListCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.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); - readWiFiNetworkDiagnosticsInteractionInfo.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); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readClusterRevisionAttribute", - readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo); - Map readWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map readWindowCoveringTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTypeCommandParams); - readWindowCoveringInteractionInfo.put( - "readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionLiftAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftCommandParams); - readWindowCoveringInteractionInfo.put( - "readCurrentPositionLiftAttribute", - readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionTiltAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltCommandParams); - readWindowCoveringInteractionInfo.put( - "readCurrentPositionTiltAttribute", - readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); - Map readWindowCoveringConfigStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readConfigStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringConfigStatusCommandParams); - readWindowCoveringInteractionInfo.put( - "readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionLiftPercentageAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionLiftPercentageAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercentageCommandParams); - readWindowCoveringInteractionInfo.put( - "readCurrentPositionLiftPercentageAttribute", - readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionTiltPercentageAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionTiltPercentageAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercentageCommandParams); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.put( - "readOperationalStatusAttribute", - readWindowCoveringOperationalStatusAttributeInteractionInfo); - Map - readWindowCoveringTargetPositionLiftPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readTargetPositionLiftPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .TargetPositionLiftPercent100thsAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTargetPositionLiftPercent100thsCommandParams); - readWindowCoveringInteractionInfo.put( - "readTargetPositionLiftPercent100thsAttribute", - readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); - Map - readWindowCoveringTargetPositionTiltPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readTargetPositionTiltPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .TargetPositionTiltPercent100thsAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTargetPositionTiltPercent100thsCommandParams); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.put( - "readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); - Map - readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionLiftPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionLiftPercent100thsAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercent100thsCommandParams); - readWindowCoveringInteractionInfo.put( - "readCurrentPositionLiftPercent100thsAttribute", - readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); - Map - readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionTiltPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionTiltPercent100thsAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercent100thsCommandParams); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.put( - "readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); - Map readWindowCoveringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterAttributeListAttributeCallback(), - readWindowCoveringAttributeListCommandParams); - readWindowCoveringInteractionInfo.put( - "readAttributeListAttribute", readWindowCoveringAttributeListAttributeInteractionInfo); - Map readWindowCoveringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsFeatureMapCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.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 + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo); + Map readWindowCoveringInteractionInfo = new LinkedHashMap<>(); + Map readWindowCoveringTypeCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readTypeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTypeCommandParams + ); + readWindowCoveringInteractionInfo.put("readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftCommandParams + ); + readWindowCoveringInteractionInfo.put("readCurrentPositionLiftAttribute", readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltCommandParams + ); + readWindowCoveringInteractionInfo.put("readCurrentPositionTiltAttribute", readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); + Map readWindowCoveringConfigStatusCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readConfigStatusAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringConfigStatusCommandParams + ); + readWindowCoveringInteractionInfo.put("readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercentageAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercentageAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercentageCommandParams + ); + readWindowCoveringInteractionInfo.put("readCurrentPositionLiftPercentageAttribute", readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercentageAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercentageAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercentageCommandParams + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.put("readOperationalStatusAttribute", readWindowCoveringOperationalStatusAttributeInteractionInfo); + Map readWindowCoveringTargetPositionLiftPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionLiftPercent100thsAttribute( + ( ChipClusters.WindowCoveringCluster.TargetPositionLiftPercent100thsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTargetPositionLiftPercent100thsCommandParams + ); + readWindowCoveringInteractionInfo.put("readTargetPositionLiftPercent100thsAttribute", readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); + Map readWindowCoveringTargetPositionTiltPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionTiltPercent100thsAttribute( + ( ChipClusters.WindowCoveringCluster.TargetPositionTiltPercent100thsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTargetPositionTiltPercent100thsCommandParams + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.put("readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercent100thsAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercent100thsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercent100thsCommandParams + ); + readWindowCoveringInteractionInfo.put("readCurrentPositionLiftPercent100thsAttribute", readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercent100thsAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercent100thsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercent100thsCommandParams + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.put("readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); + Map readWindowCoveringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readAttributeListAttribute( + ( ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterAttributeListAttributeCallback(), + readWindowCoveringAttributeListCommandParams + ); + readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.put( - "readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("windowCovering", readWindowCoveringInteractionInfo); - return readAttributeMap; + readWindowCoveringFeatureMapCommandParams + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.put("readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("windowCovering", readWindowCoveringInteractionInfo); + return readAttributeMap; } } + diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java index 4ee787dfd94515..a70c5b71a4a9de 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java @@ -29,2466 +29,2293 @@ public class ClusterWriteMapping { public Map> getWriteAttributeMap() { Map> writeAttributeMap = new HashMap<>(); - Map writeAccessControlInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("accessControl", writeAccessControlInteractionInfo); - Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); - Map writeAdministratorCommissioningInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "administratorCommissioning", writeAdministratorCommissioningInteractionInfo); - Map writeApplicationBasicInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("applicationBasic", writeApplicationBasicInteractionInfo); - Map writeApplicationLauncherInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("applicationLauncher", writeApplicationLauncherInteractionInfo); - Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); - Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); - Map writeBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBasicNodeLabelCommandParams = - new LinkedHashMap(); - CommandParameterInfo basicnodeLabelCommandParameterInfo = - new CommandParameterInfo("value", String.class); - writeBasicNodeLabelCommandParams.put("value", basicnodeLabelCommandParameterInfo); - InteractionInfo writeBasicNodeLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .writeNodeLabelAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicNodeLabelCommandParams); - writeBasicInteractionInfo.put( - "writeNodeLabelAttribute", writeBasicNodeLabelAttributeInteractionInfo); - Map writeBasicLocationCommandParams = - new LinkedHashMap(); - CommandParameterInfo basiclocationCommandParameterInfo = - new CommandParameterInfo("value", String.class); - writeBasicLocationCommandParams.put("value", basiclocationCommandParameterInfo); - InteractionInfo writeBasicLocationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .writeLocationAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicLocationCommandParams); - writeBasicInteractionInfo.put( - "writeLocationAttribute", writeBasicLocationAttributeInteractionInfo); - Map writeBasicLocalConfigDisabledCommandParams = - new LinkedHashMap(); - CommandParameterInfo basiclocalConfigDisabledCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeBasicLocalConfigDisabledCommandParams.put( - "value", basiclocalConfigDisabledCommandParameterInfo); - InteractionInfo writeBasicLocalConfigDisabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .writeLocalConfigDisabledAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicLocalConfigDisabledCommandParams); - writeBasicInteractionInfo.put( - "writeLocalConfigDisabledAttribute", writeBasicLocalConfigDisabledAttributeInteractionInfo); - writeAttributeMap.put("basic", writeBasicInteractionInfo); - Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBinaryInputBasicOutOfServiceCommandParams = - new LinkedHashMap(); - CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); - Map writeBindingInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("binding", writeBindingInteractionInfo); - Map writeBooleanStateInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("booleanState", writeBooleanStateInteractionInfo); - Map writeBridgedActionsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("bridgedActions", writeBridgedActionsInteractionInfo); - Map writeBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("bridgedDeviceBasic", writeBridgedDeviceBasicInteractionInfo); - Map writeChannelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("channel", writeChannelInteractionInfo); - Map writeColorControlInteractionInfo = new LinkedHashMap<>(); - Map writeColorControlColorControlOptionsCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlcolorControlOptionsCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeColorControlColorControlOptionsCommandParams.put( - "value", colorControlcolorControlOptionsCommandParameterInfo); - InteractionInfo writeColorControlColorControlOptionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeColorControlOptionsAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorControlOptionsCommandParams); - writeColorControlInteractionInfo.put( - "writeColorControlOptionsAttribute", - writeColorControlColorControlOptionsAttributeInteractionInfo); - Map writeColorControlWhitePointXCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlwhitePointXCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlwhitePointYCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); - Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map writeContentLauncherSupportedStreamingProtocolsCommandParams = - new LinkedHashMap(); - CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); - Map writeDescriptorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("descriptor", writeDescriptorInteractionInfo); - Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); - Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); - Map writeDoorLockLanguageCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocklanguageCommandParameterInfo = - new CommandParameterInfo("value", 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 writeDoorLockAutoRelockTimeCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = - new CommandParameterInfo("value", 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); - 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 writeDoorLockEnableOneTouchLockingCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = - new CommandParameterInfo("value", 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 writeDoorLockEnablePrivacyModeButtonCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = - new CommandParameterInfo("value", 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 writeDoorLockWrongCodeEntryLimitCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); - Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); - Map writeEthernetNetworkDiagnosticsInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); - Map writeFixedLabelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("fixedLabel", writeFixedLabelInteractionInfo); - Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); - Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeGeneralCommissioningBreadcrumbCommandParams = - new LinkedHashMap(); - CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); - Map writeGeneralDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); - Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("groupKeyManagement", writeGroupKeyManagementInteractionInfo); - Map writeGroupsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("groups", writeGroupsInteractionInfo); - Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); - Map writeIdentifyIdentifyTimeCommandParams = - new LinkedHashMap(); - CommandParameterInfo identifyidentifyTimeCommandParameterInfo = - new CommandParameterInfo("value", 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 writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); - Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); - Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); - Map writeLevelControlOptionsCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControloptionsCommandParameterInfo = - new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo levelControlonLevelCommandParameterInfo = - new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); - Map writeLocalizationConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map writeLocalizationConfigurationActiveLocaleCommandParams = - new LinkedHashMap(); - CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = - new CommandParameterInfo("value", 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); - Map writeLowPowerInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("lowPower", writeLowPowerInteractionInfo); - Map writeMediaInputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("mediaInput", writeMediaInputInteractionInfo); - Map writeMediaPlaybackInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("mediaPlayback", writeMediaPlaybackInteractionInfo); - Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); - Map writeModeSelectOnModeCommandParams = - new LinkedHashMap(); - CommandParameterInfo modeSelectonModeCommandParameterInfo = - new CommandParameterInfo("value", 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 writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeNetworkCommissioningInterfaceEnabledCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); - Map writeOtaSoftwareUpdateProviderInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); - Map writeOtaSoftwareUpdateRequestorInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); - Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); - Map writeOnOffInteractionInfo = new LinkedHashMap<>(); - Map writeOnOffOnTimeCommandParams = - new LinkedHashMap(); - CommandParameterInfo onOffonTimeCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = - new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); - Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); - Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); - Map writePowerSourceConfigurationInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); - Map writePressureMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); - Map writePumpConfigurationAndControlInteractionInfo = - new LinkedHashMap<>(); - Map - writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = - new LinkedHashMap(); - CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = - new CommandParameterInfo("value", 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); - Map writeRelativeHumidityMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); - Map writeScenesInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("scenes", writeScenesInteractionInfo); - Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); - Map writeSwitchInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("switch", writeSwitchInteractionInfo); - Map writeTargetNavigatorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("targetNavigator", writeTargetNavigatorInteractionInfo); - Map writeTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("temperatureMeasurement", writeTemperatureMeasurementInteractionInfo); - Map writeTestClusterInteractionInfo = new LinkedHashMap<>(); - Map writeTestClusterBooleanCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterbooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterBooleanCommandParams.put("value", testClusterbooleanCommandParameterInfo); - InteractionInfo writeTestClusterBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBooleanCommandParams); - writeTestClusterInteractionInfo.put( - "writeBooleanAttribute", writeTestClusterBooleanAttributeInteractionInfo); - Map writeTestClusterBitmap8CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterbitmap8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterBitmap8CommandParams.put("value", testClusterbitmap8CommandParameterInfo); - InteractionInfo writeTestClusterBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeBitmap8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap8CommandParams); - writeTestClusterInteractionInfo.put( - "writeBitmap8Attribute", writeTestClusterBitmap8AttributeInteractionInfo); - Map writeTestClusterBitmap16CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterbitmap16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterBitmap16CommandParams.put("value", testClusterbitmap16CommandParameterInfo); - InteractionInfo writeTestClusterBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeBitmap16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap16CommandParams); - writeTestClusterInteractionInfo.put( - "writeBitmap16Attribute", writeTestClusterBitmap16AttributeInteractionInfo); - Map writeTestClusterBitmap32CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterbitmap32CommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterBitmap32CommandParams.put("value", testClusterbitmap32CommandParameterInfo); - InteractionInfo writeTestClusterBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeBitmap32Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap32CommandParams); - writeTestClusterInteractionInfo.put( - "writeBitmap32Attribute", writeTestClusterBitmap32AttributeInteractionInfo); - Map writeTestClusterBitmap64CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterbitmap64CommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterBitmap64CommandParams.put("value", testClusterbitmap64CommandParameterInfo); - InteractionInfo writeTestClusterBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeBitmap64Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap64CommandParams); - writeTestClusterInteractionInfo.put( - "writeBitmap64Attribute", writeTestClusterBitmap64AttributeInteractionInfo); - Map writeTestClusterInt8uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterInt8uCommandParams.put("value", testClusterint8uCommandParameterInfo); - InteractionInfo writeTestClusterInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt8uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt8uAttribute", writeTestClusterInt8uAttributeInteractionInfo); - Map writeTestClusterInt16uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterInt16uCommandParams.put("value", testClusterint16uCommandParameterInfo); - InteractionInfo writeTestClusterInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt16uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt16uAttribute", writeTestClusterInt16uAttributeInteractionInfo); - Map writeTestClusterInt24uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint24uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt24uCommandParams.put("value", testClusterint24uCommandParameterInfo); - InteractionInfo writeTestClusterInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt24uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt24uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt24uAttribute", writeTestClusterInt24uAttributeInteractionInfo); - Map writeTestClusterInt32uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint32uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt32uCommandParams.put("value", testClusterint32uCommandParameterInfo); - InteractionInfo writeTestClusterInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt32uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt32uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt32uAttribute", writeTestClusterInt32uAttributeInteractionInfo); - Map writeTestClusterInt40uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint40uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt40uCommandParams.put("value", testClusterint40uCommandParameterInfo); - InteractionInfo writeTestClusterInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt40uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt40uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt40uAttribute", writeTestClusterInt40uAttributeInteractionInfo); - Map writeTestClusterInt48uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint48uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt48uCommandParams.put("value", testClusterint48uCommandParameterInfo); - InteractionInfo writeTestClusterInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt48uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt48uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt48uAttribute", writeTestClusterInt48uAttributeInteractionInfo); - Map writeTestClusterInt56uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint56uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt56uCommandParams.put("value", testClusterint56uCommandParameterInfo); - InteractionInfo writeTestClusterInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt56uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt56uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt56uAttribute", writeTestClusterInt56uAttributeInteractionInfo); - Map writeTestClusterInt64uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint64uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt64uCommandParams.put("value", testClusterint64uCommandParameterInfo); - InteractionInfo writeTestClusterInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt64uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt64uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt64uAttribute", writeTestClusterInt64uAttributeInteractionInfo); - Map writeTestClusterInt8sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterInt8sCommandParams.put("value", testClusterint8sCommandParameterInfo); - InteractionInfo writeTestClusterInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt8sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt8sAttribute", writeTestClusterInt8sAttributeInteractionInfo); - Map writeTestClusterInt16sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterInt16sCommandParams.put("value", testClusterint16sCommandParameterInfo); - InteractionInfo writeTestClusterInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt16sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt16sAttribute", writeTestClusterInt16sAttributeInteractionInfo); - Map writeTestClusterInt24sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint24sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt24sCommandParams.put("value", testClusterint24sCommandParameterInfo); - InteractionInfo writeTestClusterInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt24sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt24sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt24sAttribute", writeTestClusterInt24sAttributeInteractionInfo); - Map writeTestClusterInt32sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint32sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt32sCommandParams.put("value", testClusterint32sCommandParameterInfo); - InteractionInfo writeTestClusterInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt32sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt32sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt32sAttribute", writeTestClusterInt32sAttributeInteractionInfo); - Map writeTestClusterInt40sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint40sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt40sCommandParams.put("value", testClusterint40sCommandParameterInfo); - InteractionInfo writeTestClusterInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt40sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt40sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt40sAttribute", writeTestClusterInt40sAttributeInteractionInfo); - Map writeTestClusterInt48sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint48sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt48sCommandParams.put("value", testClusterint48sCommandParameterInfo); - InteractionInfo writeTestClusterInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt48sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt48sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt48sAttribute", writeTestClusterInt48sAttributeInteractionInfo); - Map writeTestClusterInt56sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint56sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt56sCommandParams.put("value", testClusterint56sCommandParameterInfo); - InteractionInfo writeTestClusterInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt56sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt56sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt56sAttribute", writeTestClusterInt56sAttributeInteractionInfo); - Map writeTestClusterInt64sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint64sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt64sCommandParams.put("value", testClusterint64sCommandParameterInfo); - InteractionInfo writeTestClusterInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt64sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt64sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt64sAttribute", writeTestClusterInt64sAttributeInteractionInfo); - Map writeTestClusterEnum8CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterenum8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterEnum8CommandParams.put("value", testClusterenum8CommandParameterInfo); - InteractionInfo writeTestClusterEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeEnum8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnum8CommandParams); - writeTestClusterInteractionInfo.put( - "writeEnum8Attribute", writeTestClusterEnum8AttributeInteractionInfo); - Map writeTestClusterEnum16CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterenum16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterEnum16CommandParams.put("value", testClusterenum16CommandParameterInfo); - InteractionInfo writeTestClusterEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeEnum16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnum16CommandParams); - writeTestClusterInteractionInfo.put( - "writeEnum16Attribute", writeTestClusterEnum16AttributeInteractionInfo); - Map writeTestClusterFloatSingleCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterfloatSingleCommandParameterInfo = - new CommandParameterInfo("value", Float.class); - writeTestClusterFloatSingleCommandParams.put( - "value", testClusterfloatSingleCommandParameterInfo); - InteractionInfo writeTestClusterFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeFloatSingleAttribute( - (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterFloatSingleCommandParams); - writeTestClusterInteractionInfo.put( - "writeFloatSingleAttribute", writeTestClusterFloatSingleAttributeInteractionInfo); - Map writeTestClusterFloatDoubleCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterfloatDoubleCommandParameterInfo = - new CommandParameterInfo("value", Double.class); - writeTestClusterFloatDoubleCommandParams.put( - "value", testClusterfloatDoubleCommandParameterInfo); - InteractionInfo writeTestClusterFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeFloatDoubleAttribute( - (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterFloatDoubleCommandParams); - writeTestClusterInteractionInfo.put( - "writeFloatDoubleAttribute", writeTestClusterFloatDoubleAttributeInteractionInfo); - Map writeTestClusterOctetStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusteroctetStringCommandParameterInfo = - new CommandParameterInfo("value", byte[].class); - writeTestClusterOctetStringCommandParams.put( - "value", testClusteroctetStringCommandParameterInfo); - InteractionInfo writeTestClusterOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeOctetStringAttribute( - (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterOctetStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeOctetStringAttribute", writeTestClusterOctetStringAttributeInteractionInfo); - Map writeTestClusterLongOctetStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterlongOctetStringCommandParameterInfo = - new CommandParameterInfo("value", byte[].class); - writeTestClusterLongOctetStringCommandParams.put( - "value", testClusterlongOctetStringCommandParameterInfo); - InteractionInfo writeTestClusterLongOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeLongOctetStringAttribute( - (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterLongOctetStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeLongOctetStringAttribute", writeTestClusterLongOctetStringAttributeInteractionInfo); - Map writeTestClusterCharStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustercharStringCommandParameterInfo = - new CommandParameterInfo("value", String.class); - writeTestClusterCharStringCommandParams.put("value", testClustercharStringCommandParameterInfo); - InteractionInfo writeTestClusterCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeCharStringAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterCharStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeCharStringAttribute", writeTestClusterCharStringAttributeInteractionInfo); - Map writeTestClusterLongCharStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterlongCharStringCommandParameterInfo = - new CommandParameterInfo("value", String.class); - writeTestClusterLongCharStringCommandParams.put( - "value", testClusterlongCharStringCommandParameterInfo); - InteractionInfo writeTestClusterLongCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeLongCharStringAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterLongCharStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeLongCharStringAttribute", writeTestClusterLongCharStringAttributeInteractionInfo); - Map writeTestClusterEpochUsCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterepochUsCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterEpochUsCommandParams.put("value", testClusterepochUsCommandParameterInfo); - InteractionInfo writeTestClusterEpochUsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeEpochUsAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEpochUsCommandParams); - writeTestClusterInteractionInfo.put( - "writeEpochUsAttribute", writeTestClusterEpochUsAttributeInteractionInfo); - Map writeTestClusterEpochSCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterepochSCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterEpochSCommandParams.put("value", testClusterepochSCommandParameterInfo); - InteractionInfo writeTestClusterEpochSAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeEpochSAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEpochSCommandParams); - writeTestClusterInteractionInfo.put( - "writeEpochSAttribute", writeTestClusterEpochSAttributeInteractionInfo); - Map writeTestClusterVendorIdCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustervendorIdCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterVendorIdCommandParams.put("value", testClustervendorIdCommandParameterInfo); - InteractionInfo writeTestClusterVendorIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeVendorIdAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterVendorIdCommandParams); - writeTestClusterInteractionInfo.put( - "writeVendorIdAttribute", writeTestClusterVendorIdAttributeInteractionInfo); - Map writeTestClusterEnumAttrCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterenumAttrCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterEnumAttrCommandParams.put("value", testClusterenumAttrCommandParameterInfo); - InteractionInfo writeTestClusterEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeEnumAttrAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnumAttrCommandParams); - writeTestClusterInteractionInfo.put( - "writeEnumAttrAttribute", writeTestClusterEnumAttrAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt8uCommandParams.put( - "value", testClusterrangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt8uCommandParams); - writeTestClusterInteractionInfo.put( - "writeRangeRestrictedInt8uAttribute", - writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt8sCommandParams.put( - "value", testClusterrangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt8sCommandParams); - writeTestClusterInteractionInfo.put( - "writeRangeRestrictedInt8sAttribute", - writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt16uCommandParams.put( - "value", testClusterrangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt16uCommandParams); - writeTestClusterInteractionInfo.put( - "writeRangeRestrictedInt16uAttribute", - writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt16sCommandParams.put( - "value", testClusterrangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt16sCommandParams); - writeTestClusterInteractionInfo.put( - "writeRangeRestrictedInt16sAttribute", - writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo); - Map writeTestClusterTimedWriteBooleanCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertimedWriteBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterTimedWriteBooleanCommandParams.put( - "value", testClustertimedWriteBooleanCommandParameterInfo); - InteractionInfo writeTestClusterTimedWriteBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeTimedWriteBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value"), - 10000); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterTimedWriteBooleanCommandParams); - writeTestClusterInteractionInfo.put( - "writeTimedWriteBooleanAttribute", - writeTestClusterTimedWriteBooleanAttributeInteractionInfo); - Map writeTestClusterGeneralErrorBooleanCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustergeneralErrorBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterGeneralErrorBooleanCommandParams.put( - "value", testClustergeneralErrorBooleanCommandParameterInfo); - InteractionInfo writeTestClusterGeneralErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeGeneralErrorBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterGeneralErrorBooleanCommandParams); - writeTestClusterInteractionInfo.put( - "writeGeneralErrorBooleanAttribute", - writeTestClusterGeneralErrorBooleanAttributeInteractionInfo); - Map writeTestClusterClusterErrorBooleanCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterclusterErrorBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterClusterErrorBooleanCommandParams.put( - "value", testClusterclusterErrorBooleanCommandParameterInfo); - InteractionInfo writeTestClusterClusterErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeClusterErrorBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterClusterErrorBooleanCommandParams); - writeTestClusterInteractionInfo.put( - "writeClusterErrorBooleanAttribute", - writeTestClusterClusterErrorBooleanAttributeInteractionInfo); - Map writeTestClusterUnsupportedCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterunsupportedCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterUnsupportedCommandParams.put( - "value", testClusterunsupportedCommandParameterInfo); - InteractionInfo writeTestClusterUnsupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeUnsupportedAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterUnsupportedCommandParams); - writeTestClusterInteractionInfo.put( - "writeUnsupportedAttribute", writeTestClusterUnsupportedAttributeInteractionInfo); - Map writeTestClusterNullableBooleanCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterNullableBooleanCommandParams.put( - "value", testClusternullableBooleanCommandParameterInfo); - InteractionInfo writeTestClusterNullableBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBooleanCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableBooleanAttribute", writeTestClusterNullableBooleanAttributeInteractionInfo); - Map writeTestClusterNullableBitmap8CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableBitmap8CommandParams.put( - "value", testClusternullableBitmap8CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableBitmap8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap8CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableBitmap8Attribute", writeTestClusterNullableBitmap8AttributeInteractionInfo); - Map writeTestClusterNullableBitmap16CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableBitmap16CommandParams.put( - "value", testClusternullableBitmap16CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableBitmap16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap16CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableBitmap16Attribute", writeTestClusterNullableBitmap16AttributeInteractionInfo); - Map writeTestClusterNullableBitmap32CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap32CommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableBitmap32CommandParams.put( - "value", testClusternullableBitmap32CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableBitmap32Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap32CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableBitmap32Attribute", writeTestClusterNullableBitmap32AttributeInteractionInfo); - Map writeTestClusterNullableBitmap64CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap64CommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableBitmap64CommandParams.put( - "value", testClusternullableBitmap64CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableBitmap64Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap64CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableBitmap64Attribute", writeTestClusterNullableBitmap64AttributeInteractionInfo); - Map writeTestClusterNullableInt8uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt8uCommandParams.put( - "value", testClusternullableInt8uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt8uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt8uAttribute", writeTestClusterNullableInt8uAttributeInteractionInfo); - Map writeTestClusterNullableInt16uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt16uCommandParams.put( - "value", testClusternullableInt16uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt16uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt16uAttribute", writeTestClusterNullableInt16uAttributeInteractionInfo); - Map writeTestClusterNullableInt24uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt24uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt24uCommandParams.put( - "value", testClusternullableInt24uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt24uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt24uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt24uAttribute", writeTestClusterNullableInt24uAttributeInteractionInfo); - Map writeTestClusterNullableInt32uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt32uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt32uCommandParams.put( - "value", testClusternullableInt32uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt32uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt32uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt32uAttribute", writeTestClusterNullableInt32uAttributeInteractionInfo); - Map writeTestClusterNullableInt40uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt40uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt40uCommandParams.put( - "value", testClusternullableInt40uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt40uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt40uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt40uAttribute", writeTestClusterNullableInt40uAttributeInteractionInfo); - Map writeTestClusterNullableInt48uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt48uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt48uCommandParams.put( - "value", testClusternullableInt48uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt48uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt48uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt48uAttribute", writeTestClusterNullableInt48uAttributeInteractionInfo); - Map writeTestClusterNullableInt56uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt56uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt56uCommandParams.put( - "value", testClusternullableInt56uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt56uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt56uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt56uAttribute", writeTestClusterNullableInt56uAttributeInteractionInfo); - Map writeTestClusterNullableInt64uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt64uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt64uCommandParams.put( - "value", testClusternullableInt64uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt64uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt64uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt64uAttribute", writeTestClusterNullableInt64uAttributeInteractionInfo); - Map writeTestClusterNullableInt8sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt8sCommandParams.put( - "value", testClusternullableInt8sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt8sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt8sAttribute", writeTestClusterNullableInt8sAttributeInteractionInfo); - Map writeTestClusterNullableInt16sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt16sCommandParams.put( - "value", testClusternullableInt16sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt16sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt16sAttribute", writeTestClusterNullableInt16sAttributeInteractionInfo); - Map writeTestClusterNullableInt24sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt24sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt24sCommandParams.put( - "value", testClusternullableInt24sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt24sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt24sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt24sAttribute", writeTestClusterNullableInt24sAttributeInteractionInfo); - Map writeTestClusterNullableInt32sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt32sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt32sCommandParams.put( - "value", testClusternullableInt32sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt32sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt32sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt32sAttribute", writeTestClusterNullableInt32sAttributeInteractionInfo); - Map writeTestClusterNullableInt40sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt40sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt40sCommandParams.put( - "value", testClusternullableInt40sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt40sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt40sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt40sAttribute", writeTestClusterNullableInt40sAttributeInteractionInfo); - Map writeTestClusterNullableInt48sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt48sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt48sCommandParams.put( - "value", testClusternullableInt48sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt48sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt48sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt48sAttribute", writeTestClusterNullableInt48sAttributeInteractionInfo); - Map writeTestClusterNullableInt56sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt56sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt56sCommandParams.put( - "value", testClusternullableInt56sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt56sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt56sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt56sAttribute", writeTestClusterNullableInt56sAttributeInteractionInfo); - Map writeTestClusterNullableInt64sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt64sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt64sCommandParams.put( - "value", testClusternullableInt64sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt64sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt64sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt64sAttribute", writeTestClusterNullableInt64sAttributeInteractionInfo); - Map writeTestClusterNullableEnum8CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableEnum8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnum8CommandParams.put( - "value", testClusternullableEnum8CommandParameterInfo); - InteractionInfo writeTestClusterNullableEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableEnum8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnum8CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableEnum8Attribute", writeTestClusterNullableEnum8AttributeInteractionInfo); - Map writeTestClusterNullableEnum16CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableEnum16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnum16CommandParams.put( - "value", testClusternullableEnum16CommandParameterInfo); - InteractionInfo writeTestClusterNullableEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableEnum16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnum16CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableEnum16Attribute", writeTestClusterNullableEnum16AttributeInteractionInfo); - Map writeTestClusterNullableFloatSingleCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableFloatSingleCommandParameterInfo = - new CommandParameterInfo("value", Float.class); - writeTestClusterNullableFloatSingleCommandParams.put( - "value", testClusternullableFloatSingleCommandParameterInfo); - InteractionInfo writeTestClusterNullableFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableFloatSingleAttribute( - (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableFloatSingleCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableFloatSingleAttribute", - writeTestClusterNullableFloatSingleAttributeInteractionInfo); - Map writeTestClusterNullableFloatDoubleCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableFloatDoubleCommandParameterInfo = - new CommandParameterInfo("value", Double.class); - writeTestClusterNullableFloatDoubleCommandParams.put( - "value", testClusternullableFloatDoubleCommandParameterInfo); - InteractionInfo writeTestClusterNullableFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableFloatDoubleAttribute( - (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableFloatDoubleCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableFloatDoubleAttribute", - writeTestClusterNullableFloatDoubleAttributeInteractionInfo); - Map writeTestClusterNullableOctetStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableOctetStringCommandParameterInfo = - new CommandParameterInfo("value", byte[].class); - writeTestClusterNullableOctetStringCommandParams.put( - "value", testClusternullableOctetStringCommandParameterInfo); - InteractionInfo writeTestClusterNullableOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableOctetStringAttribute( - (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableOctetStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableOctetStringAttribute", - writeTestClusterNullableOctetStringAttributeInteractionInfo); - Map writeTestClusterNullableCharStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableCharStringCommandParameterInfo = - new CommandParameterInfo("value", String.class); - writeTestClusterNullableCharStringCommandParams.put( - "value", testClusternullableCharStringCommandParameterInfo); - InteractionInfo writeTestClusterNullableCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableCharStringAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableCharStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableCharStringAttribute", - writeTestClusterNullableCharStringAttributeInteractionInfo); - Map writeTestClusterNullableEnumAttrCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableEnumAttrCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnumAttrCommandParams.put( - "value", testClusternullableEnumAttrCommandParameterInfo); - InteractionInfo writeTestClusterNullableEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableEnumAttrAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnumAttrCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableEnumAttrAttribute", writeTestClusterNullableEnumAttrAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt8uCommandParams.put( - "value", testClusternullableRangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt8uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableRangeRestrictedInt8uAttribute", - writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt8sCommandParams.put( - "value", testClusternullableRangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt8sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableRangeRestrictedInt8sAttribute", - writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt16uCommandParams.put( - "value", testClusternullableRangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt16uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableRangeRestrictedInt16uAttribute", - writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt16sCommandParams.put( - "value", testClusternullableRangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt16sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableRangeRestrictedInt16sAttribute", - writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); - writeAttributeMap.put("testCluster", writeTestClusterInteractionInfo); - Map writeThermostatInteractionInfo = new LinkedHashMap<>(); - Map writeThermostatOccupiedCoolingSetpointCommandParams = - new LinkedHashMap(); - CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = - new CommandParameterInfo("value", 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 writeThermostatMinHeatSetpointLimitCommandParams = - new LinkedHashMap(); - CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = - new CommandParameterInfo("value", 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 writeThermostatControlSequenceOfOperationCommandParams = - new LinkedHashMap(); - CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatsystemModeCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); - Map writeThermostatUserInterfaceConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map - writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = - new LinkedHashMap(); - CommandParameterInfo - thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = - new CommandParameterInfo("value", 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); - 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); - Map writeThreadNetworkDiagnosticsInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); - Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeTimeFormatLocalizationHourFormatCommandParams = - new LinkedHashMap(); - CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); - Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeUnitLocalizationTemperatureUnitCommandParams = - new LinkedHashMap(); - CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); - Map writeUserLabelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("userLabel", writeUserLabelInteractionInfo); - Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); - Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); - Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map writeWindowCoveringModeCommandParams = - new LinkedHashMap(); - CommandParameterInfo windowCoveringmodeCommandParameterInfo = - new CommandParameterInfo("value", 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 writeAccessControlInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("accessControl", writeAccessControlInteractionInfo); + Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); + Map writeAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("administratorCommissioning", writeAdministratorCommissioningInteractionInfo); + Map writeApplicationBasicInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("applicationBasic", writeApplicationBasicInteractionInfo); + Map writeApplicationLauncherInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("applicationLauncher", writeApplicationLauncherInteractionInfo); + Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); + Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); + Map writeBasicInteractionInfo = new LinkedHashMap<>(); + Map writeBasicNodeLabelCommandParams = new LinkedHashMap(); + CommandParameterInfo basicnodeLabelCommandParameterInfo = new CommandParameterInfo("value", String.class); + writeBasicNodeLabelCommandParams.put("value",basicnodeLabelCommandParameterInfo); + InteractionInfo writeBasicNodeLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).writeNodeLabelAttribute( + (DefaultClusterCallback) callback, + (String) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicNodeLabelCommandParams + ); + writeBasicInteractionInfo.put("writeNodeLabelAttribute", writeBasicNodeLabelAttributeInteractionInfo); + Map writeBasicLocationCommandParams = new LinkedHashMap(); + CommandParameterInfo basiclocationCommandParameterInfo = new CommandParameterInfo("value", String.class); + writeBasicLocationCommandParams.put("value",basiclocationCommandParameterInfo); + InteractionInfo writeBasicLocationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).writeLocationAttribute( + (DefaultClusterCallback) callback, + (String) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicLocationCommandParams + ); + writeBasicInteractionInfo.put("writeLocationAttribute", writeBasicLocationAttributeInteractionInfo); + Map writeBasicLocalConfigDisabledCommandParams = new LinkedHashMap(); + CommandParameterInfo basiclocalConfigDisabledCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeBasicLocalConfigDisabledCommandParams.put("value",basiclocalConfigDisabledCommandParameterInfo); + InteractionInfo writeBasicLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).writeLocalConfigDisabledAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicLocalConfigDisabledCommandParams + ); + writeBasicInteractionInfo.put("writeLocalConfigDisabledAttribute", writeBasicLocalConfigDisabledAttributeInteractionInfo); + writeAttributeMap.put("basic", writeBasicInteractionInfo); + Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); + Map writeBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); + CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); + Map writeBindingInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("binding", writeBindingInteractionInfo); + Map writeBooleanStateInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("booleanState", writeBooleanStateInteractionInfo); + Map writeBridgedActionsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bridgedActions", writeBridgedActionsInteractionInfo); + Map writeBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bridgedDeviceBasic", writeBridgedDeviceBasicInteractionInfo); + Map writeChannelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("channel", writeChannelInteractionInfo); + Map writeColorControlInteractionInfo = new LinkedHashMap<>(); + Map writeColorControlColorControlOptionsCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlcolorControlOptionsCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeColorControlColorControlOptionsCommandParams.put("value",colorControlcolorControlOptionsCommandParameterInfo); + InteractionInfo writeColorControlColorControlOptionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeColorControlOptionsAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorControlOptionsCommandParams + ); + writeColorControlInteractionInfo.put("writeColorControlOptionsAttribute", writeColorControlColorControlOptionsAttributeInteractionInfo); + Map writeColorControlWhitePointXCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlwhitePointXCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlwhitePointYCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); + Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); + Map writeContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); + CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); + Map writeDescriptorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("descriptor", writeDescriptorInteractionInfo); + Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); + Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); + Map writeDoorLockLanguageCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocklanguageCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = new CommandParameterInfo("value", 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); + 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 writeDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); + Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); + Map writeEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); + Map writeFixedLabelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("fixedLabel", writeFixedLabelInteractionInfo); + Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); + Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); + Map writeGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); + CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); + Map writeGeneralDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); + Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("groupKeyManagement", writeGroupKeyManagementInteractionInfo); + Map writeGroupsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("groups", writeGroupsInteractionInfo); + Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); + Map writeIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); + CommandParameterInfo identifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("value", 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 writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); + Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); + Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); + Map writeLevelControlOptionsCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControloptionsCommandParameterInfo = new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo levelControlonLevelCommandParameterInfo = new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); + Map writeLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); + Map writeLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); + CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = new CommandParameterInfo("value", 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); + Map writeLowPowerInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("lowPower", writeLowPowerInteractionInfo); + Map writeMediaInputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("mediaInput", writeMediaInputInteractionInfo); + Map writeMediaPlaybackInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("mediaPlayback", writeMediaPlaybackInteractionInfo); + Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); + Map writeModeSelectOnModeCommandParams = new LinkedHashMap(); + CommandParameterInfo modeSelectonModeCommandParameterInfo = new CommandParameterInfo("value", 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 writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); + Map writeNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); + Map writeOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); + Map writeOtaSoftwareUpdateRequestorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); + Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); + Map writeOnOffInteractionInfo = new LinkedHashMap<>(); + Map writeOnOffOnTimeCommandParams = new LinkedHashMap(); + CommandParameterInfo onOffonTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); + Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); + Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); + Map writePowerSourceConfigurationInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); + Map writePressureMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); + Map writePumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); + Map writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); + CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = new CommandParameterInfo("value", 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); + Map writeRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); + Map writeScenesInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("scenes", writeScenesInteractionInfo); + Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); + Map writeSwitchInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("switch", writeSwitchInteractionInfo); + Map writeTargetNavigatorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("targetNavigator", writeTargetNavigatorInteractionInfo); + Map writeTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("temperatureMeasurement", writeTemperatureMeasurementInteractionInfo); + Map writeTestClusterInteractionInfo = new LinkedHashMap<>(); + Map writeTestClusterBooleanCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterbooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterBooleanCommandParams.put("value",testClusterbooleanCommandParameterInfo); + InteractionInfo writeTestClusterBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBooleanCommandParams + ); + writeTestClusterInteractionInfo.put("writeBooleanAttribute", writeTestClusterBooleanAttributeInteractionInfo); + Map writeTestClusterBitmap8CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterbitmap8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterBitmap8CommandParams.put("value",testClusterbitmap8CommandParameterInfo); + InteractionInfo writeTestClusterBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeBitmap8Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap8CommandParams + ); + writeTestClusterInteractionInfo.put("writeBitmap8Attribute", writeTestClusterBitmap8AttributeInteractionInfo); + Map writeTestClusterBitmap16CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterbitmap16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterBitmap16CommandParams.put("value",testClusterbitmap16CommandParameterInfo); + InteractionInfo writeTestClusterBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeBitmap16Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap16CommandParams + ); + writeTestClusterInteractionInfo.put("writeBitmap16Attribute", writeTestClusterBitmap16AttributeInteractionInfo); + Map writeTestClusterBitmap32CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterbitmap32CommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterBitmap32CommandParams.put("value",testClusterbitmap32CommandParameterInfo); + InteractionInfo writeTestClusterBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeBitmap32Attribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap32CommandParams + ); + writeTestClusterInteractionInfo.put("writeBitmap32Attribute", writeTestClusterBitmap32AttributeInteractionInfo); + Map writeTestClusterBitmap64CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterbitmap64CommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterBitmap64CommandParams.put("value",testClusterbitmap64CommandParameterInfo); + InteractionInfo writeTestClusterBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeBitmap64Attribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap64CommandParams + ); + writeTestClusterInteractionInfo.put("writeBitmap64Attribute", writeTestClusterBitmap64AttributeInteractionInfo); + Map writeTestClusterInt8uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterInt8uCommandParams.put("value",testClusterint8uCommandParameterInfo); + InteractionInfo writeTestClusterInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt8uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt8uAttribute", writeTestClusterInt8uAttributeInteractionInfo); + Map writeTestClusterInt16uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterInt16uCommandParams.put("value",testClusterint16uCommandParameterInfo); + InteractionInfo writeTestClusterInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt16uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt16uAttribute", writeTestClusterInt16uAttributeInteractionInfo); + Map writeTestClusterInt24uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint24uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt24uCommandParams.put("value",testClusterint24uCommandParameterInfo); + InteractionInfo writeTestClusterInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt24uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt24uAttribute", writeTestClusterInt24uAttributeInteractionInfo); + Map writeTestClusterInt32uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint32uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt32uCommandParams.put("value",testClusterint32uCommandParameterInfo); + InteractionInfo writeTestClusterInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt32uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt32uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt32uAttribute", writeTestClusterInt32uAttributeInteractionInfo); + Map writeTestClusterInt40uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint40uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt40uCommandParams.put("value",testClusterint40uCommandParameterInfo); + InteractionInfo writeTestClusterInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt40uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt40uAttribute", writeTestClusterInt40uAttributeInteractionInfo); + Map writeTestClusterInt48uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint48uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt48uCommandParams.put("value",testClusterint48uCommandParameterInfo); + InteractionInfo writeTestClusterInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt48uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt48uAttribute", writeTestClusterInt48uAttributeInteractionInfo); + Map writeTestClusterInt56uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint56uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt56uCommandParams.put("value",testClusterint56uCommandParameterInfo); + InteractionInfo writeTestClusterInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt56uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt56uAttribute", writeTestClusterInt56uAttributeInteractionInfo); + Map writeTestClusterInt64uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint64uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt64uCommandParams.put("value",testClusterint64uCommandParameterInfo); + InteractionInfo writeTestClusterInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt64uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt64uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt64uAttribute", writeTestClusterInt64uAttributeInteractionInfo); + Map writeTestClusterInt8sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterInt8sCommandParams.put("value",testClusterint8sCommandParameterInfo); + InteractionInfo writeTestClusterInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt8sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt8sAttribute", writeTestClusterInt8sAttributeInteractionInfo); + Map writeTestClusterInt16sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterInt16sCommandParams.put("value",testClusterint16sCommandParameterInfo); + InteractionInfo writeTestClusterInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt16sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt16sAttribute", writeTestClusterInt16sAttributeInteractionInfo); + Map writeTestClusterInt24sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint24sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt24sCommandParams.put("value",testClusterint24sCommandParameterInfo); + InteractionInfo writeTestClusterInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt24sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt24sAttribute", writeTestClusterInt24sAttributeInteractionInfo); + Map writeTestClusterInt32sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint32sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt32sCommandParams.put("value",testClusterint32sCommandParameterInfo); + InteractionInfo writeTestClusterInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt32sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt32sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt32sAttribute", writeTestClusterInt32sAttributeInteractionInfo); + Map writeTestClusterInt40sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint40sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt40sCommandParams.put("value",testClusterint40sCommandParameterInfo); + InteractionInfo writeTestClusterInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt40sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt40sAttribute", writeTestClusterInt40sAttributeInteractionInfo); + Map writeTestClusterInt48sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint48sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt48sCommandParams.put("value",testClusterint48sCommandParameterInfo); + InteractionInfo writeTestClusterInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt48sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt48sAttribute", writeTestClusterInt48sAttributeInteractionInfo); + Map writeTestClusterInt56sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint56sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt56sCommandParams.put("value",testClusterint56sCommandParameterInfo); + InteractionInfo writeTestClusterInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt56sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt56sAttribute", writeTestClusterInt56sAttributeInteractionInfo); + Map writeTestClusterInt64sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint64sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt64sCommandParams.put("value",testClusterint64sCommandParameterInfo); + InteractionInfo writeTestClusterInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt64sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt64sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt64sAttribute", writeTestClusterInt64sAttributeInteractionInfo); + Map writeTestClusterEnum8CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterenum8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterEnum8CommandParams.put("value",testClusterenum8CommandParameterInfo); + InteractionInfo writeTestClusterEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeEnum8Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnum8CommandParams + ); + writeTestClusterInteractionInfo.put("writeEnum8Attribute", writeTestClusterEnum8AttributeInteractionInfo); + Map writeTestClusterEnum16CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterenum16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterEnum16CommandParams.put("value",testClusterenum16CommandParameterInfo); + InteractionInfo writeTestClusterEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeEnum16Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnum16CommandParams + ); + writeTestClusterInteractionInfo.put("writeEnum16Attribute", writeTestClusterEnum16AttributeInteractionInfo); + Map writeTestClusterFloatSingleCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterfloatSingleCommandParameterInfo = new CommandParameterInfo("value", Float.class); + writeTestClusterFloatSingleCommandParams.put("value",testClusterfloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeFloatSingleAttribute( + (DefaultClusterCallback) callback, + (Float) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatSingleCommandParams + ); + writeTestClusterInteractionInfo.put("writeFloatSingleAttribute", writeTestClusterFloatSingleAttributeInteractionInfo); + Map writeTestClusterFloatDoubleCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterfloatDoubleCommandParameterInfo = new CommandParameterInfo("value", Double.class); + writeTestClusterFloatDoubleCommandParams.put("value",testClusterfloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeFloatDoubleAttribute( + (DefaultClusterCallback) callback, + (Double) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatDoubleCommandParams + ); + writeTestClusterInteractionInfo.put("writeFloatDoubleAttribute", writeTestClusterFloatDoubleAttributeInteractionInfo); + Map writeTestClusterOctetStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusteroctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); + writeTestClusterOctetStringCommandParams.put("value",testClusteroctetStringCommandParameterInfo); + InteractionInfo writeTestClusterOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeOctetStringAttribute( + (DefaultClusterCallback) callback, + (byte[]) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterOctetStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeOctetStringAttribute", writeTestClusterOctetStringAttributeInteractionInfo); + Map writeTestClusterLongOctetStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterlongOctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); + writeTestClusterLongOctetStringCommandParams.put("value",testClusterlongOctetStringCommandParameterInfo); + InteractionInfo writeTestClusterLongOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeLongOctetStringAttribute( + (DefaultClusterCallback) callback, + (byte[]) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterLongOctetStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeLongOctetStringAttribute", writeTestClusterLongOctetStringAttributeInteractionInfo); + Map writeTestClusterCharStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustercharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); + writeTestClusterCharStringCommandParams.put("value",testClustercharStringCommandParameterInfo); + InteractionInfo writeTestClusterCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeCharStringAttribute( + (DefaultClusterCallback) callback, + (String) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterCharStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeCharStringAttribute", writeTestClusterCharStringAttributeInteractionInfo); + Map writeTestClusterLongCharStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterlongCharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); + writeTestClusterLongCharStringCommandParams.put("value",testClusterlongCharStringCommandParameterInfo); + InteractionInfo writeTestClusterLongCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeLongCharStringAttribute( + (DefaultClusterCallback) callback, + (String) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterLongCharStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeLongCharStringAttribute", writeTestClusterLongCharStringAttributeInteractionInfo); + Map writeTestClusterEpochUsCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterepochUsCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterEpochUsCommandParams.put("value",testClusterepochUsCommandParameterInfo); + InteractionInfo writeTestClusterEpochUsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeEpochUsAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEpochUsCommandParams + ); + writeTestClusterInteractionInfo.put("writeEpochUsAttribute", writeTestClusterEpochUsAttributeInteractionInfo); + Map writeTestClusterEpochSCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterepochSCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterEpochSCommandParams.put("value",testClusterepochSCommandParameterInfo); + InteractionInfo writeTestClusterEpochSAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeEpochSAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEpochSCommandParams + ); + writeTestClusterInteractionInfo.put("writeEpochSAttribute", writeTestClusterEpochSAttributeInteractionInfo); + Map writeTestClusterVendorIdCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustervendorIdCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterVendorIdCommandParams.put("value",testClustervendorIdCommandParameterInfo); + InteractionInfo writeTestClusterVendorIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeVendorIdAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterVendorIdCommandParams + ); + writeTestClusterInteractionInfo.put("writeVendorIdAttribute", writeTestClusterVendorIdAttributeInteractionInfo); + Map writeTestClusterEnumAttrCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterenumAttrCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterEnumAttrCommandParams.put("value",testClusterenumAttrCommandParameterInfo); + InteractionInfo writeTestClusterEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeEnumAttrAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnumAttrCommandParams + ); + writeTestClusterInteractionInfo.put("writeEnumAttrAttribute", writeTestClusterEnumAttrAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt8uCommandParams.put("value",testClusterrangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8uCommandParams + ); + writeTestClusterInteractionInfo.put("writeRangeRestrictedInt8uAttribute", writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt8sCommandParams.put("value",testClusterrangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8sCommandParams + ); + writeTestClusterInteractionInfo.put("writeRangeRestrictedInt8sAttribute", writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt16uCommandParams.put("value",testClusterrangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16uCommandParams + ); + writeTestClusterInteractionInfo.put("writeRangeRestrictedInt16uAttribute", writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt16sCommandParams.put("value",testClusterrangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16sCommandParams + ); + writeTestClusterInteractionInfo.put("writeRangeRestrictedInt16sAttribute", writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo); + Map writeTestClusterTimedWriteBooleanCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertimedWriteBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterTimedWriteBooleanCommandParams.put("value",testClustertimedWriteBooleanCommandParameterInfo); + InteractionInfo writeTestClusterTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeTimedWriteBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + , 10000 + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterTimedWriteBooleanCommandParams + ); + writeTestClusterInteractionInfo.put("writeTimedWriteBooleanAttribute", writeTestClusterTimedWriteBooleanAttributeInteractionInfo); + Map writeTestClusterGeneralErrorBooleanCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustergeneralErrorBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterGeneralErrorBooleanCommandParams.put("value",testClustergeneralErrorBooleanCommandParameterInfo); + InteractionInfo writeTestClusterGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeGeneralErrorBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterGeneralErrorBooleanCommandParams + ); + writeTestClusterInteractionInfo.put("writeGeneralErrorBooleanAttribute", writeTestClusterGeneralErrorBooleanAttributeInteractionInfo); + Map writeTestClusterClusterErrorBooleanCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterclusterErrorBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterClusterErrorBooleanCommandParams.put("value",testClusterclusterErrorBooleanCommandParameterInfo); + InteractionInfo writeTestClusterClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeClusterErrorBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterClusterErrorBooleanCommandParams + ); + writeTestClusterInteractionInfo.put("writeClusterErrorBooleanAttribute", writeTestClusterClusterErrorBooleanAttributeInteractionInfo); + Map writeTestClusterUnsupportedCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterunsupportedCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterUnsupportedCommandParams.put("value",testClusterunsupportedCommandParameterInfo); + InteractionInfo writeTestClusterUnsupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeUnsupportedAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterUnsupportedCommandParams + ); + writeTestClusterInteractionInfo.put("writeUnsupportedAttribute", writeTestClusterUnsupportedAttributeInteractionInfo); + Map writeTestClusterNullableBooleanCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterNullableBooleanCommandParams.put("value",testClusternullableBooleanCommandParameterInfo); + InteractionInfo writeTestClusterNullableBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBooleanCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableBooleanAttribute", writeTestClusterNullableBooleanAttributeInteractionInfo); + Map writeTestClusterNullableBitmap8CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableBitmap8CommandParams.put("value",testClusternullableBitmap8CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap8Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap8CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableBitmap8Attribute", writeTestClusterNullableBitmap8AttributeInteractionInfo); + Map writeTestClusterNullableBitmap16CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableBitmap16CommandParams.put("value",testClusternullableBitmap16CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap16Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap16CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableBitmap16Attribute", writeTestClusterNullableBitmap16AttributeInteractionInfo); + Map writeTestClusterNullableBitmap32CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap32CommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableBitmap32CommandParams.put("value",testClusternullableBitmap32CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap32Attribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap32CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableBitmap32Attribute", writeTestClusterNullableBitmap32AttributeInteractionInfo); + Map writeTestClusterNullableBitmap64CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap64CommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableBitmap64CommandParams.put("value",testClusternullableBitmap64CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap64Attribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap64CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableBitmap64Attribute", writeTestClusterNullableBitmap64AttributeInteractionInfo); + Map writeTestClusterNullableInt8uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt8uCommandParams.put("value",testClusternullableInt8uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt8uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt8uAttribute", writeTestClusterNullableInt8uAttributeInteractionInfo); + Map writeTestClusterNullableInt16uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt16uCommandParams.put("value",testClusternullableInt16uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt16uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt16uAttribute", writeTestClusterNullableInt16uAttributeInteractionInfo); + Map writeTestClusterNullableInt24uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt24uCommandParams.put("value",testClusternullableInt24uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt24uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt24uAttribute", writeTestClusterNullableInt24uAttributeInteractionInfo); + Map writeTestClusterNullableInt32uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt32uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt32uCommandParams.put("value",testClusternullableInt32uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt32uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt32uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt32uAttribute", writeTestClusterNullableInt32uAttributeInteractionInfo); + Map writeTestClusterNullableInt40uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt40uCommandParams.put("value",testClusternullableInt40uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt40uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt40uAttribute", writeTestClusterNullableInt40uAttributeInteractionInfo); + Map writeTestClusterNullableInt48uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt48uCommandParams.put("value",testClusternullableInt48uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt48uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt48uAttribute", writeTestClusterNullableInt48uAttributeInteractionInfo); + Map writeTestClusterNullableInt56uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt56uCommandParams.put("value",testClusternullableInt56uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt56uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt56uAttribute", writeTestClusterNullableInt56uAttributeInteractionInfo); + Map writeTestClusterNullableInt64uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt64uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt64uCommandParams.put("value",testClusternullableInt64uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt64uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt64uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt64uAttribute", writeTestClusterNullableInt64uAttributeInteractionInfo); + Map writeTestClusterNullableInt8sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt8sCommandParams.put("value",testClusternullableInt8sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt8sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt8sAttribute", writeTestClusterNullableInt8sAttributeInteractionInfo); + Map writeTestClusterNullableInt16sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt16sCommandParams.put("value",testClusternullableInt16sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt16sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt16sAttribute", writeTestClusterNullableInt16sAttributeInteractionInfo); + Map writeTestClusterNullableInt24sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt24sCommandParams.put("value",testClusternullableInt24sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt24sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt24sAttribute", writeTestClusterNullableInt24sAttributeInteractionInfo); + Map writeTestClusterNullableInt32sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt32sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt32sCommandParams.put("value",testClusternullableInt32sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt32sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt32sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt32sAttribute", writeTestClusterNullableInt32sAttributeInteractionInfo); + Map writeTestClusterNullableInt40sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt40sCommandParams.put("value",testClusternullableInt40sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt40sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt40sAttribute", writeTestClusterNullableInt40sAttributeInteractionInfo); + Map writeTestClusterNullableInt48sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt48sCommandParams.put("value",testClusternullableInt48sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt48sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt48sAttribute", writeTestClusterNullableInt48sAttributeInteractionInfo); + Map writeTestClusterNullableInt56sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt56sCommandParams.put("value",testClusternullableInt56sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt56sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt56sAttribute", writeTestClusterNullableInt56sAttributeInteractionInfo); + Map writeTestClusterNullableInt64sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt64sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt64sCommandParams.put("value",testClusternullableInt64sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt64sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt64sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt64sAttribute", writeTestClusterNullableInt64sAttributeInteractionInfo); + Map writeTestClusterNullableEnum8CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableEnum8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnum8CommandParams.put("value",testClusternullableEnum8CommandParameterInfo); + InteractionInfo writeTestClusterNullableEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableEnum8Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnum8CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableEnum8Attribute", writeTestClusterNullableEnum8AttributeInteractionInfo); + Map writeTestClusterNullableEnum16CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableEnum16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnum16CommandParams.put("value",testClusternullableEnum16CommandParameterInfo); + InteractionInfo writeTestClusterNullableEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableEnum16Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnum16CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableEnum16Attribute", writeTestClusterNullableEnum16AttributeInteractionInfo); + Map writeTestClusterNullableFloatSingleCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatSingleCommandParameterInfo = new CommandParameterInfo("value", Float.class); + writeTestClusterNullableFloatSingleCommandParams.put("value",testClusternullableFloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableFloatSingleAttribute( + (DefaultClusterCallback) callback, + (Float) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatSingleCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableFloatSingleAttribute", writeTestClusterNullableFloatSingleAttributeInteractionInfo); + Map writeTestClusterNullableFloatDoubleCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatDoubleCommandParameterInfo = new CommandParameterInfo("value", Double.class); + writeTestClusterNullableFloatDoubleCommandParams.put("value",testClusternullableFloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableFloatDoubleAttribute( + (DefaultClusterCallback) callback, + (Double) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatDoubleCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableFloatDoubleAttribute", writeTestClusterNullableFloatDoubleAttributeInteractionInfo); + Map writeTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableOctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); + writeTestClusterNullableOctetStringCommandParams.put("value",testClusternullableOctetStringCommandParameterInfo); + InteractionInfo writeTestClusterNullableOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableOctetStringAttribute( + (DefaultClusterCallback) callback, + (byte[]) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableOctetStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableOctetStringAttribute", writeTestClusterNullableOctetStringAttributeInteractionInfo); + Map writeTestClusterNullableCharStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableCharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); + writeTestClusterNullableCharStringCommandParams.put("value",testClusternullableCharStringCommandParameterInfo); + InteractionInfo writeTestClusterNullableCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableCharStringAttribute( + (DefaultClusterCallback) callback, + (String) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableCharStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableCharStringAttribute", writeTestClusterNullableCharStringAttributeInteractionInfo); + Map writeTestClusterNullableEnumAttrCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableEnumAttrCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnumAttrCommandParams.put("value",testClusternullableEnumAttrCommandParameterInfo); + InteractionInfo writeTestClusterNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableEnumAttrAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnumAttrCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableEnumAttrAttribute", writeTestClusterNullableEnumAttrAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt8uCommandParams.put("value",testClusternullableRangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt8uAttribute", writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt8sCommandParams.put("value",testClusternullableRangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt8sAttribute", writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt16uCommandParams.put("value",testClusternullableRangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt16uAttribute", writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt16sCommandParams.put("value",testClusternullableRangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt16sAttribute", writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); + writeAttributeMap.put("testCluster", writeTestClusterInteractionInfo); + Map writeThermostatInteractionInfo = new LinkedHashMap<>(); + Map writeThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = new CommandParameterInfo("value", 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 writeThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = new CommandParameterInfo("value", 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 writeThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatsystemModeCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); + Map writeThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); + Map writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = new CommandParameterInfo("value", 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); + 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); + Map writeThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); + Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); + Map writeTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); + CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); + Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); + Map writeUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); + CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); + Map writeUserLabelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("userLabel", writeUserLabelInteractionInfo); + Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); + Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); + Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); + Map writeWindowCoveringModeCommandParams = new LinkedHashMap(); + CommandParameterInfo windowCoveringmodeCommandParameterInfo = new CommandParameterInfo("value", 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); return writeAttributeMap; } } + diff --git a/zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.cpp b/zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.cpp deleted file mode 100755 index 006fc302c5615a..00000000000000 --- a/zzz_generated/lock-app/zap-generated/CHIPClientCallbacks.cpp +++ /dev/null @@ -1,174 +0,0 @@ -/* - * - * Copyright (c) 2022 Project CHIP Authors - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// THIS FILE IS GENERATED BY ZAP - -#include - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -using namespace ::chip; -using namespace ::chip::app::DataModel; - -namespace { -[[maybe_unused]] constexpr uint16_t kByteSpanSizeLengthInBytes = 2; -} // namespace - -#define CHECK_STATUS_WITH_RETVAL(error, retval) \ - if (CHIP_NO_ERROR != error) \ - { \ - ChipLogError(Zcl, "CHECK_STATUS %s", ErrorStr(error)); \ - if (onFailureCallback != nullptr) \ - { \ - Callback::Callback * cb = \ - Callback::Callback::FromCancelable(onFailureCallback); \ - cb->mCall(cb->mContext, static_cast(EMBER_ZCL_STATUS_INVALID_VALUE)); \ - } \ - return retval; \ - } - -#define CHECK_STATUS(error) CHECK_STATUS_WITH_RETVAL(error, true) -#define CHECK_STATUS_VOID(error) CHECK_STATUS_WITH_RETVAL(error, ) - -#define CHECK_MESSAGE_LENGTH_WITH_RETVAL(value, retval) \ - if (!CanCastTo(value)) \ - { \ - ChipLogError(Zcl, "CHECK_MESSAGE_LENGTH expects a uint16_t value, got: %d", value); \ - if (onFailureCallback != nullptr) \ - { \ - Callback::Callback * cb = \ - Callback::Callback::FromCancelable(onFailureCallback); \ - cb->mCall(cb->mContext, static_cast(EMBER_ZCL_STATUS_INVALID_VALUE)); \ - } \ - return retval; \ - } \ - \ - if (messageLen < value) \ - { \ - ChipLogError(Zcl, "Unexpected response length: %d", messageLen); \ - if (onFailureCallback != nullptr) \ - { \ - Callback::Callback * cb = \ - Callback::Callback::FromCancelable(onFailureCallback); \ - cb->mCall(cb->mContext, static_cast(EMBER_ZCL_STATUS_INVALID_VALUE)); \ - } \ - return retval; \ - } \ - \ - messageLen = static_cast(messageLen - static_cast(value)); - -#define CHECK_MESSAGE_LENGTH(value) CHECK_MESSAGE_LENGTH_WITH_RETVAL(value, true) -#define CHECK_MESSAGE_LENGTH_VOID(value) CHECK_MESSAGE_LENGTH_WITH_RETVAL(value, ) - -#define GET_RESPONSE_CALLBACKS(name) \ - Callback::Cancelable * onSuccessCallback = nullptr; \ - Callback::Cancelable * onFailureCallback = nullptr; \ - NodeId sourceId = emberAfCurrentCommand()->SourceNodeId(); \ - uint8_t sequenceNumber = emberAfCurrentCommand()->seqNum; \ - CHIP_ERROR err = gCallbacks.GetResponseCallback(sourceId, sequenceNumber, &onSuccessCallback, &onFailureCallback); \ - \ - if (CHIP_NO_ERROR != err) \ - { \ - if (onSuccessCallback == nullptr) \ - { \ - ChipLogDetail(Zcl, "%s: Missing success callback", name); \ - } \ - \ - if (onFailureCallback == nullptr) \ - { \ - ChipLogDetail(Zcl, "%s: Missing failure callback", name); \ - } \ - \ - return true; \ - } - -#define GET_CLUSTER_RESPONSE_CALLBACKS(name) \ - Callback::Cancelable * onSuccessCallback = nullptr; \ - Callback::Cancelable * onFailureCallback = nullptr; \ - NodeId sourceIdentifier = reinterpret_cast(commandObj); \ - /* #6559: Currently, we only have one commands for the IMInvokeCommands and to a device, so the seqNum is always set to 0. */ \ - CHIP_ERROR err = gCallbacks.GetResponseCallback(sourceIdentifier, 0, &onSuccessCallback, &onFailureCallback); \ - \ - if (CHIP_NO_ERROR != err) \ - { \ - if (onSuccessCallback == nullptr) \ - { \ - ChipLogDetail(Zcl, "%s: Missing success callback", name); \ - } \ - \ - if (onFailureCallback == nullptr) \ - { \ - ChipLogDetail(Zcl, "%s: Missing failure callback", name); \ - } \ - \ - return true; \ - } - -// Singleton instance of the callbacks manager -app::CHIPDeviceCallbacksMgr & gCallbacks = app::CHIPDeviceCallbacksMgr::GetInstance(); - -bool emberAfOtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback(EndpointId endpoint, app::CommandSender * commandObj, - uint8_t action, uint32_t delayedActionTime) -{ - ChipLogProgress(Zcl, "ApplyUpdateResponse:"); - ChipLogProgress(Zcl, " action: %" PRIu8 "", action); - ChipLogProgress(Zcl, " delayedActionTime: %" PRIu32 "", delayedActionTime); - - GET_CLUSTER_RESPONSE_CALLBACKS("OtaSoftwareUpdateProviderClusterApplyUpdateResponseCallback"); - - Callback::Callback * cb = - Callback::Callback::FromCancelable(onSuccessCallback); - cb->mCall(cb->mContext, action, delayedActionTime); - return true; -} - -bool emberAfOtaSoftwareUpdateProviderClusterQueryImageResponseCallback(EndpointId endpoint, app::CommandSender * commandObj, - uint8_t status, uint32_t delayedActionTime, - chip::CharSpan imageURI, uint32_t softwareVersion, - chip::CharSpan softwareVersionString, - chip::ByteSpan updateToken, bool userConsentNeeded, - chip::ByteSpan metadataForRequestor) -{ - ChipLogProgress(Zcl, "QueryImageResponse:"); - ChipLogProgress(Zcl, " status: %" PRIu8 "", status); - ChipLogProgress(Zcl, " delayedActionTime: %" PRIu32 "", delayedActionTime); - ChipLogProgress(Zcl, " imageURI: %.*s", static_cast(imageURI.size()), imageURI.data()); - ChipLogProgress(Zcl, " softwareVersion: %" PRIu32 "", softwareVersion); - ChipLogProgress(Zcl, " softwareVersionString: %.*s", static_cast(softwareVersionString.size()), - softwareVersionString.data()); - ChipLogProgress(Zcl, " updateToken: %zu", updateToken.size()); - ChipLogProgress(Zcl, " userConsentNeeded: %d", userConsentNeeded); - ChipLogProgress(Zcl, " metadataForRequestor: %zu", metadataForRequestor.size()); - - GET_CLUSTER_RESPONSE_CALLBACKS("OtaSoftwareUpdateProviderClusterQueryImageResponseCallback"); - - Callback::Callback * cb = - Callback::Callback::FromCancelable(onSuccessCallback); - cb->mCall(cb->mContext, status, delayedActionTime, imageURI, softwareVersion, softwareVersionString, updateToken, - userConsentNeeded, metadataForRequestor); - return true; -} diff --git a/zzz_generated/lock-app/zap-generated/CHIPClusters.cpp b/zzz_generated/lock-app/zap-generated/CHIPClusters.cpp deleted file mode 100755 index 8ba83874fa6545..00000000000000 --- a/zzz_generated/lock-app/zap-generated/CHIPClusters.cpp +++ /dev/null @@ -1,188 +0,0 @@ -/* - * - * Copyright (c) 2022 Project CHIP Authors - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -// THIS FILE IS GENERATED BY ZAP - -#include "CHIPClusters.h" - -#include -#include - -namespace chip { - -using namespace app::Clusters; -using namespace System; -using namespace Encoding::LittleEndian; - -namespace Controller { - -// TODO(#4502): onCompletion is not used by IM for now. -// TODO(#4503): length should be passed to commands when byte string is in argument list. -// TODO(#4503): Commands should take group id as an argument. - -// OtaSoftwareUpdateProvider Cluster Commands -CHIP_ERROR OtaSoftwareUpdateProviderCluster::ApplyUpdateRequest(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, - chip::ByteSpan updateToken, uint32_t newVersion) -{ - CHIP_ERROR err = CHIP_NO_ERROR; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; - - // Used when encoding non-empty command. Suppress error message when encoding empty commands. - (void) writer; - (void) argSeqNumber; - - VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); - - app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, - OtaSoftwareUpdateProvider::Commands::ApplyUpdateRequest::Id, - (app::CommandPathFlags::kEndpointIdValid) }; - - CommandSenderHandle sender( - Platform::New(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); - - VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); - - SuccessOrExit(err = sender->PrepareCommand(cmdParams)); - - VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); - // updateToken: octetString - SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), updateToken)); - // newVersion: int32u - SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), newVersion)); - - SuccessOrExit(err = sender->FinishCommand()); - - // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - - SuccessOrExit(err = mDevice->SendCommands(sender.get(), mTimeout)); - - // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object - // now. - sender.release(); -exit: - return err; -} - -CHIP_ERROR OtaSoftwareUpdateProviderCluster::NotifyUpdateApplied(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, - chip::ByteSpan updateToken, uint32_t softwareVersion) -{ - CHIP_ERROR err = CHIP_NO_ERROR; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; - - // Used when encoding non-empty command. Suppress error message when encoding empty commands. - (void) writer; - (void) argSeqNumber; - - VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); - - app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, - OtaSoftwareUpdateProvider::Commands::NotifyUpdateApplied::Id, - (app::CommandPathFlags::kEndpointIdValid) }; - - CommandSenderHandle sender( - Platform::New(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); - - VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); - - SuccessOrExit(err = sender->PrepareCommand(cmdParams)); - - VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); - // updateToken: octetString - SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), updateToken)); - // softwareVersion: int32u - SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), softwareVersion)); - - SuccessOrExit(err = sender->FinishCommand()); - - // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - - SuccessOrExit(err = mDevice->SendCommands(sender.get(), mTimeout)); - - // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object - // now. - sender.release(); -exit: - return err; -} - -CHIP_ERROR OtaSoftwareUpdateProviderCluster::QueryImage(Callback::Cancelable * onSuccessCallback, - Callback::Cancelable * onFailureCallback, chip::VendorId vendorId, - uint16_t productId, uint32_t softwareVersion, uint8_t protocolsSupported, - uint16_t hardwareVersion, chip::CharSpan location, bool requestorCanConsent, - chip::ByteSpan metadataForProvider) -{ - CHIP_ERROR err = CHIP_NO_ERROR; - TLV::TLVWriter * writer = nullptr; - uint8_t argSeqNumber = 0; - - // Used when encoding non-empty command. Suppress error message when encoding empty commands. - (void) writer; - (void) argSeqNumber; - - VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); - - app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, - OtaSoftwareUpdateProvider::Commands::QueryImage::Id, - (app::CommandPathFlags::kEndpointIdValid) }; - - CommandSenderHandle sender( - Platform::New(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); - - VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); - - SuccessOrExit(err = sender->PrepareCommand(cmdParams)); - - VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); - // vendorId: vendorId - SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), vendorId)); - // productId: int16u - SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), productId)); - // softwareVersion: int32u - SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), softwareVersion)); - // protocolsSupported: OTADownloadProtocol - SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), protocolsSupported)); - // hardwareVersion: int16u - SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), hardwareVersion)); - // location: charString - SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), location)); - // requestorCanConsent: boolean - SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), requestorCanConsent)); - // metadataForProvider: octetString - SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), metadataForProvider)); - - SuccessOrExit(err = sender->FinishCommand()); - - // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. - mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); - - SuccessOrExit(err = mDevice->SendCommands(sender.get(), mTimeout)); - - // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object - // now. - sender.release(); -exit: - return err; -} - -} // namespace Controller -} // namespace chip diff --git a/zzz_generated/lock-app/zap-generated/CHIPClusters.h b/zzz_generated/lock-app/zap-generated/CHIPClusters.h old mode 100755 new mode 100644 diff --git a/zzz_generated/lock-app/zap-generated/gen_tokens.h b/zzz_generated/lock-app/zap-generated/gen_tokens.h old mode 100755 new mode 100644 From 88bfb88000b541a117b92d678fe29d28c6369c21 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Mon, 31 Jan 2022 21:00:18 +0000 Subject: [PATCH 09/14] Restyled by whitespace --- .../chip/devicecontroller/ChipClusters.java | 242 ++-- .../chip/devicecontroller/ChipStructs.java | 2 +- .../devicecontroller/ClusterInfoMapping.java | 1009 ++++++++--------- .../devicecontroller/ClusterReadMapping.java | 1 - .../devicecontroller/ClusterWriteMapping.java | 269 +++-- 5 files changed, 760 insertions(+), 763 deletions(-) diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index bad2cfd7e68797..84244edbcb62c1 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -86,7 +86,7 @@ public BaseChipCluster(long devicePtr, int endpointId) { public abstract long initWithDevice(long devicePtr, int endpointId); public native void deleteCluster(long chipClusterPtr); - + @SuppressWarnings("deprecation") protected void finalize() throws Throwable { super.finalize(); @@ -245,7 +245,7 @@ public void loginRequest(DefaultClusterCallback callback public void logoutRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { logoutRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -256,11 +256,11 @@ private native void loginRequest(long chipClusterPtr, DefaultClusterCallback Cal , String tempAccountIdentifier, String setupPIN , @Nullable Integer timedInvokeTimeoutMs); private native void logoutRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface GetSetupPINResponseCallback { void onSuccess(String setupPIN); - + void onError(Exception error); } @@ -336,7 +336,7 @@ public void openCommissioningWindow(DefaultClusterCallback callback public void revokeCommissioning(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -347,7 +347,7 @@ private native void openCommissioningWindow(long chipClusterPtr, DefaultClusterC , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID , @Nullable Integer timedInvokeTimeoutMs); private native void revokeCommissioning(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AdminFabricIndexAttributeCallback { @@ -703,7 +703,7 @@ private native void stopAppRequest(long chipClusterPtr, LauncherResponseCallback , @Nullable Integer timedInvokeTimeoutMs); public interface LauncherResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } @@ -930,7 +930,7 @@ public void barrierControlStop(DefaultClusterCallback callback } public void barrierControlStop(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { barrierControlStop(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -938,7 +938,7 @@ private native void barrierControlGoToPercent(long chipClusterPtr, DefaultCluste , Integer percentOpen , @Nullable Integer timedInvokeTimeoutMs); private native void barrierControlStop(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -2195,7 +2195,7 @@ private native void skipChannelRequest(long chipClusterPtr, DefaultClusterCallba , @Nullable Integer timedInvokeTimeoutMs); public interface ChangeChannelResponseCallback { void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType); - + void onError(Exception error); } @@ -3734,7 +3734,7 @@ private native void launchURLRequest(long chipClusterPtr, LaunchResponseCallback , @Nullable Integer timedInvokeTimeoutMs); public interface LaunchResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } @@ -4012,7 +4012,7 @@ private native void retrieveLogsRequest(long chipClusterPtr, RetrieveLogsRespons , @Nullable Integer timedInvokeTimeoutMs); public interface RetrieveLogsResponseCallback { void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot); - + void onError(Exception error); } @@ -4236,31 +4236,31 @@ private native void unlockWithTimeout(long chipClusterPtr, DefaultClusterCallbac , @Nullable Integer timedInvokeTimeoutMs); public interface GetCredentialStatusResponseCallback { void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); - + void onError(Exception error); } public interface GetUserResponseCallback { void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex); - + void onError(Exception error); } public interface GetWeekDayScheduleResponseCallback { void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute); - + void onError(Exception error); } public interface GetYearDayScheduleResponseCallback { void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime); - + void onError(Exception error); } public interface SetCredentialResponseCallback { void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); - + void onError(Exception error); } @@ -5062,12 +5062,12 @@ public void resetCounts(DefaultClusterCallback callback } public void resetCounts(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -5542,7 +5542,7 @@ public void commissioningComplete(CommissioningCompleteResponseCallback callback } public void commissioningComplete(CommissioningCompleteResponseCallback callback - + , int timedInvokeTimeoutMs) { commissioningComplete(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -5561,26 +5561,26 @@ private native void armFailSafe(long chipClusterPtr, ArmFailSafeResponseCallback , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs , @Nullable Integer timedInvokeTimeoutMs); private native void commissioningComplete(long chipClusterPtr, CommissioningCompleteResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void setRegulatoryConfig(long chipClusterPtr, SetRegulatoryConfigResponseCallback Callback , Integer location, String countryCode, Long breadcrumb, Long timeoutMs , @Nullable Integer timedInvokeTimeoutMs); public interface ArmFailSafeResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } public interface CommissioningCompleteResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } public interface SetRegulatoryConfigResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } @@ -6014,13 +6014,13 @@ private native void keySetWrite(long chipClusterPtr, DefaultClusterCallback Call , @Nullable Integer timedInvokeTimeoutMs); public interface KeySetReadAllIndicesResponseCallback { void onSuccess(ArrayList groupKeySetIDs); - + void onError(Exception error); } public interface KeySetReadResponseCallback { void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet); - + void onError(Exception error); } @@ -6205,7 +6205,7 @@ public void removeAllGroups(DefaultClusterCallback callback } public void removeAllGroups(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { removeAllGroups(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -6241,7 +6241,7 @@ private native void getGroupMembership(long chipClusterPtr, GetGroupMembershipRe , ArrayList groupList , @Nullable Integer timedInvokeTimeoutMs); private native void removeAllGroups(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void removeGroup(long chipClusterPtr, RemoveGroupResponseCallback Callback , Integer groupId @@ -6251,25 +6251,25 @@ private native void viewGroup(long chipClusterPtr, ViewGroupResponseCallback Cal , @Nullable Integer timedInvokeTimeoutMs); public interface AddGroupResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface GetGroupMembershipResponseCallback { void onSuccess(Integer capacity, ArrayList groupList); - + void onError(Exception error); } public interface RemoveGroupResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface ViewGroupResponseCallback { void onSuccess(Integer status, Integer groupId, String groupName); - + void onError(Exception error); } @@ -6365,7 +6365,7 @@ public void identifyQuery(IdentifyQueryResponseCallback callback } public void identifyQuery(IdentifyQueryResponseCallback callback - + , int timedInvokeTimeoutMs) { identifyQuery(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -6384,14 +6384,14 @@ private native void identify(long chipClusterPtr, DefaultClusterCallback Callbac , Integer identifyTime , @Nullable Integer timedInvokeTimeoutMs); private native void identifyQuery(long chipClusterPtr, IdentifyQueryResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void triggerEffect(long chipClusterPtr, DefaultClusterCallback Callback , Integer effectIdentifier, Integer effectVariant , @Nullable Integer timedInvokeTimeoutMs); public interface IdentifyQueryResponseCallback { void onSuccess(Integer timeout); - + void onError(Exception error); } @@ -6683,7 +6683,7 @@ private native void sendKeyRequest(long chipClusterPtr, SendKeyResponseCallback , @Nullable Integer timedInvokeTimeoutMs); public interface SendKeyResponseCallback { void onSuccess(Integer status); - + void onError(Exception error); } @@ -6826,7 +6826,7 @@ public void stopWithOnOff(DefaultClusterCallback callback } public void stopWithOnOff(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -6852,7 +6852,7 @@ private native void stop(long chipClusterPtr, DefaultClusterCallback Callback , Integer optionMask, Integer optionOverride , @Nullable Integer timedInvokeTimeoutMs); private native void stopWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface OnLevelAttributeCallback { @@ -7372,12 +7372,12 @@ public void sleep(DefaultClusterCallback callback } public void sleep(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { sleep(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void sleep(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -7441,7 +7441,7 @@ public void hideInputStatusRequest(DefaultClusterCallback callback } public void hideInputStatusRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { hideInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7474,12 +7474,12 @@ public void showInputStatusRequest(DefaultClusterCallback callback } public void showInputStatusRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { showInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void hideInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void renameInputRequest(long chipClusterPtr, DefaultClusterCallback Callback , Integer index, String name @@ -7488,7 +7488,7 @@ private native void selectInputRequest(long chipClusterPtr, DefaultClusterCallba , Integer index , @Nullable Integer timedInvokeTimeoutMs); private native void showInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface MediaInputListAttributeCallback { @@ -7595,7 +7595,7 @@ public void fastForwardRequest(PlaybackResponseCallback callback } public void fastForwardRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { fastForwardRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7606,7 +7606,7 @@ public void nextRequest(PlaybackResponseCallback callback } public void nextRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { nextRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7617,7 +7617,7 @@ public void pauseRequest(PlaybackResponseCallback callback } public void pauseRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { pauseRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7628,7 +7628,7 @@ public void playRequest(PlaybackResponseCallback callback } public void playRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { playRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7639,7 +7639,7 @@ public void previousRequest(PlaybackResponseCallback callback } public void previousRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { previousRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7650,7 +7650,7 @@ public void rewindRequest(PlaybackResponseCallback callback } public void rewindRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { rewindRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7694,7 +7694,7 @@ public void startOverRequest(PlaybackResponseCallback callback } public void startOverRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { startOverRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7705,27 +7705,27 @@ public void stopRequest(PlaybackResponseCallback callback } public void stopRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { stopRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void fastForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void nextRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void pauseRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void playRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void previousRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void rewindRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void seekRequest(long chipClusterPtr, PlaybackResponseCallback Callback , Long position @@ -7737,14 +7737,14 @@ private native void skipForwardRequest(long chipClusterPtr, PlaybackResponseCall , Long deltaPositionMilliseconds , @Nullable Integer timedInvokeTimeoutMs); private native void startOverRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void stopRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface PlaybackResponseCallback { void onSuccess(Integer status); - + void onError(Exception error); } @@ -8181,19 +8181,19 @@ private native void scanNetworks(long chipClusterPtr, ScanNetworksResponseCallba , @Nullable Integer timedInvokeTimeoutMs); public interface ConnectNetworkResponseCallback { void onSuccess(Integer networkingStatus, String debugText, Long errorValue); - + void onError(Exception error); } public interface NetworkConfigResponseCallback { void onSuccess(Integer networkingStatus, String debugText); - + void onError(Exception error); } public interface ScanNetworksResponseCallback { void onSuccess(Integer networkingStatus, String debugText, Optional> wiFiScanResults, Optional> threadScanResults); - + void onError(Exception error); } @@ -8457,13 +8457,13 @@ private native void queryImage(long chipClusterPtr, QueryImageResponseCallback C , @Nullable Integer timedInvokeTimeoutMs); public interface ApplyUpdateResponseCallback { void onSuccess(Integer action, Long delayedActionTime); - + void onError(Exception error); } public interface QueryImageResponseCallback { void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor); - + void onError(Exception error); } @@ -8805,7 +8805,7 @@ public void off(DefaultClusterCallback callback } public void off(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { off(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -8827,7 +8827,7 @@ public void on(DefaultClusterCallback callback } public void on(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { on(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -8838,7 +8838,7 @@ public void onWithRecallGlobalScene(DefaultClusterCallback callback } public void onWithRecallGlobalScene(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { onWithRecallGlobalScene(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -8860,27 +8860,27 @@ public void toggle(DefaultClusterCallback callback } public void toggle(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { toggle(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void off(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void offWithEffect(long chipClusterPtr, DefaultClusterCallback Callback , Integer effectId, Integer effectVariant , @Nullable Integer timedInvokeTimeoutMs); private native void on(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void onWithRecallGlobalScene(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void onWithTimedOff(long chipClusterPtr, DefaultClusterCallback Callback , Integer onOffControl, Integer onTime, Integer offWaitTime , @Nullable Integer timedInvokeTimeoutMs); private native void toggle(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -9308,25 +9308,25 @@ private native void updateNOC(long chipClusterPtr, NOCResponseCallback Callback , @Nullable Integer timedInvokeTimeoutMs); public interface AttestationResponseCallback { void onSuccess(byte[] attestationElements, byte[] signature); - + void onError(Exception error); } public interface CertificateChainResponseCallback { void onSuccess(byte[] certificate); - + void onError(Exception error); } public interface NOCResponseCallback { void onSuccess(Integer statusCode, Integer fabricIndex, String debugText); - + void onError(Exception error); } public interface OpCSRResponseCallback { void onSuccess(byte[] NOCSRElements, byte[] attestationSignature); - + void onError(Exception error); } @@ -10767,37 +10767,37 @@ private native void viewScene(long chipClusterPtr, ViewSceneResponseCallback Cal , @Nullable Integer timedInvokeTimeoutMs); public interface AddSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface GetSceneMembershipResponseCallback { void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList); - + void onError(Exception error); } public interface RemoveAllScenesResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface RemoveSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface StoreSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface ViewSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets); - + void onError(Exception error); } @@ -10958,12 +10958,12 @@ public void resetWatermarks(DefaultClusterCallback callback } public void resetWatermarks(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetWatermarks(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetWatermarks(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface ThreadMetricsAttributeCallback { @@ -11267,7 +11267,7 @@ private native void navigateTargetRequest(long chipClusterPtr, NavigateTargetRes , @Nullable Integer timedInvokeTimeoutMs); public interface NavigateTargetResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } @@ -11518,7 +11518,7 @@ public void test(DefaultClusterCallback callback } public void test(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { test(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11628,7 +11628,7 @@ public void testNotHandled(DefaultClusterCallback callback } public void testNotHandled(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11661,7 +11661,7 @@ public void testSpecific(TestSpecificResponseCallback callback } public void testSpecific(TestSpecificResponseCallback callback - + , int timedInvokeTimeoutMs) { testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11683,14 +11683,14 @@ public void testUnknownCommand(DefaultClusterCallback callback } public void testUnknownCommand(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); } public void timedInvokeRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11698,7 +11698,7 @@ private native void simpleStructEchoRequest(long chipClusterPtr, SimpleStructRes , ChipStructs.TestClusterClusterSimpleStruct arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void test(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void testAddArguments(long chipClusterPtr, TestAddArgumentsResponseCallback Callback , Integer arg1, Integer arg2 @@ -11728,7 +11728,7 @@ private native void testNestedStructListArgumentRequest(long chipClusterPtr, Boo , ChipStructs.TestClusterClusterNestedStructList arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void testNotHandled(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void testNullableOptionalRequest(long chipClusterPtr, TestNullableOptionalResponseCallback Callback , @Nullable Optional arg1 @@ -11737,62 +11737,62 @@ private native void testSimpleOptionalArgumentRequest(long chipClusterPtr, Defau , Optional arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void testSpecific(long chipClusterPtr, TestSpecificResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void testStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback , ChipStructs.TestClusterClusterSimpleStruct arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void testUnknownCommand(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void timedInvokeRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface BooleanResponseCallback { void onSuccess(Boolean value); - + void onError(Exception error); } public interface SimpleStructResponseCallback { void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); - + void onError(Exception error); } public interface TestAddArgumentsResponseCallback { void onSuccess(Integer returnValue); - + void onError(Exception error); } public interface TestEmitTestEventResponseCallback { void onSuccess(Long value); - + void onError(Exception error); } public interface TestEnumsResponseCallback { void onSuccess(Integer arg1, Integer arg2); - + void onError(Exception error); } public interface TestListInt8UReverseResponseCallback { void onSuccess(ArrayList arg1); - + void onError(Exception error); } public interface TestNullableOptionalResponseCallback { void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue); - + void onError(Exception error); } public interface TestSpecificResponseCallback { void onSuccess(Integer returnValue); - + void onError(Exception error); } @@ -14220,7 +14220,7 @@ public void clearWeeklySchedule(DefaultClusterCallback callback } public void clearWeeklySchedule(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { clearWeeklySchedule(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -14231,7 +14231,7 @@ public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback } public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback - + , int timedInvokeTimeoutMs) { getRelayStatusLog(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -14269,10 +14269,10 @@ public void setpointRaiseLower(DefaultClusterCallback callback setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs); } private native void clearWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void getRelayStatusLog(long chipClusterPtr, GetRelayStatusLogResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void getWeeklySchedule(long chipClusterPtr, GetWeeklyScheduleResponseCallback Callback , Integer daysToReturn, Integer modeToReturn @@ -14285,13 +14285,13 @@ private native void setpointRaiseLower(long chipClusterPtr, DefaultClusterCallba , @Nullable Integer timedInvokeTimeoutMs); public interface GetRelayStatusLogResponseCallback { void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries); - + void onError(Exception error); } public interface GetWeeklyScheduleResponseCallback { void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload); - + void onError(Exception error); } @@ -14919,12 +14919,12 @@ public void resetCounts(DefaultClusterCallback callback } public void resetCounts(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface NeighborTableListAttributeCallback { @@ -16556,12 +16556,12 @@ public void resetCounts(DefaultClusterCallback callback } public void resetCounts(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -16891,7 +16891,7 @@ public void downOrClose(DefaultClusterCallback callback } public void downOrClose(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { downOrClose(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -16946,7 +16946,7 @@ public void stopMotion(DefaultClusterCallback callback } public void stopMotion(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { stopMotion(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -16957,12 +16957,12 @@ public void upOrOpen(DefaultClusterCallback callback } public void upOrOpen(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { upOrOpen(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void downOrClose(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void goToLiftPercentage(long chipClusterPtr, DefaultClusterCallback Callback , Integer liftPercentageValue, Integer liftPercent100thsValue @@ -16977,10 +16977,10 @@ private native void goToTiltValue(long chipClusterPtr, DefaultClusterCallback Ca , Integer tiltValue , @Nullable Integer timedInvokeTimeoutMs); private native void stopMotion(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void upOrOpen(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface CurrentPositionLiftAttributeCallback { diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java index 23446754ab399f..19853055a448c2 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java @@ -2130,4 +2130,4 @@ public String toString() { } } -} \ No newline at end of file +} diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index 206c331e05b755..36b3755afb50ea 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -1024,7 +1024,7 @@ public void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Lo responseValues.put(userTypeResponseValue, userType); CommandResponseInfo credentialRuleResponseValue = new CommandResponseInfo("credentialRule", "Integer"); responseValues.put(credentialRuleResponseValue, credentialRule); - // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * + // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet CommandResponseInfo creatorFabricIndexResponseValue = new CommandResponseInfo("creatorFabricIndex", "Integer"); responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); @@ -1479,7 +1479,7 @@ public void setCallbackDelegate(ClusterCommandCallback callback) { @Override public void onSuccess(ArrayList groupKeySetIDs) { Map responseValues = new LinkedHashMap<>(); - // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * + // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -1609,7 +1609,7 @@ public void onSuccess(Integer capacity, ArrayList groupList) { Map responseValues = new LinkedHashMap<>(); CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); responseValues.put(capacityResponseValue, capacity); - // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * + // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -2045,9 +2045,9 @@ public void onSuccess(Integer NetworkingStatus, String DebugText, Optional arg1) { Map responseValues = new LinkedHashMap<>(); - // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * + // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -3258,7 +3258,7 @@ public void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekF responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); CommandResponseInfo modeForSequenceResponseValue = new CommandResponseInfo("modeForSequence", "Integer"); responseValues.put(modeForSequenceResponseValue, modeForSequence); - // payload: /* TYPE WARNING: array array defaults to */ uint8_t * + // payload: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -3824,7 +3824,7 @@ public Map> getCommandMap() { Map accountLogingetSetupPINRequestCommandParams = new LinkedHashMap(); CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); accountLogingetSetupPINRequestCommandParams.put("tempAccountIdentifier",accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); - + InteractionInfo accountLogingetSetupPINRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AccountLoginCluster) cluster) @@ -3841,10 +3841,10 @@ public Map> getCommandMap() { Map accountLoginloginRequestCommandParams = new LinkedHashMap(); CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); accountLoginloginRequestCommandParams.put("tempAccountIdentifier",accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); - + CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = new CommandParameterInfo("setupPIN", String.class); accountLoginloginRequestCommandParams.put("setupPIN",accountLoginloginRequestsetupPINCommandParameterInfo); - + InteractionInfo accountLoginloginRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AccountLoginCluster) cluster) @@ -3877,7 +3877,7 @@ public Map> getCommandMap() { Map administratorCommissioningopenBasicCommissioningWindowCommandParams = new LinkedHashMap(); CommandParameterInfo administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); administratorCommissioningopenBasicCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); - + InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AdministratorCommissioningCluster) cluster) @@ -3894,22 +3894,22 @@ public Map> getCommandMap() { Map administratorCommissioningopenCommissioningWindowCommandParams = new LinkedHashMap(); CommandParameterInfo administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); administratorCommissioningopenCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = new CommandParameterInfo("PAKEVerifier", byte[].class); administratorCommissioningopenCommissioningWindowCommandParams.put("PAKEVerifier",administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = new CommandParameterInfo("discriminator", Integer.class); administratorCommissioningopenCommissioningWindowCommandParams.put("discriminator",administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = new CommandParameterInfo("iterations", Long.class); administratorCommissioningopenCommissioningWindowCommandParams.put("iterations",administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = new CommandParameterInfo("salt", byte[].class); administratorCommissioningopenCommissioningWindowCommandParams.put("salt",administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = new CommandParameterInfo("passcodeID", Integer.class); administratorCommissioningopenCommissioningWindowCommandParams.put("passcodeID",administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); - + InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AdministratorCommissioningCluster) cluster) @@ -3956,7 +3956,7 @@ public Map> getCommandMap() { .hideAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) commandArguments.get("application") - + ); }, () -> new DelegatedLauncherResponseCallback(), @@ -3966,7 +3966,7 @@ public Map> getCommandMap() { Map applicationLauncherlaunchAppRequestCommandParams = new LinkedHashMap(); CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); applicationLauncherlaunchAppRequestCommandParams.put("data",applicationLauncherlaunchAppRequestdataCommandParameterInfo); - + InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationLauncherCluster) cluster) @@ -3975,7 +3975,7 @@ public Map> getCommandMap() { commandArguments.get("data") , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) commandArguments.get("application") - + ); }, () -> new DelegatedLauncherResponseCallback(), @@ -3989,7 +3989,7 @@ public Map> getCommandMap() { .stopAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) commandArguments.get("application") - + ); }, () -> new DelegatedLauncherResponseCallback(), @@ -4001,10 +4001,10 @@ public Map> getCommandMap() { Map audioOutputrenameOutputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); audioOutputrenameOutputRequestCommandParams.put("index",audioOutputrenameOutputRequestindexCommandParameterInfo); - + CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); audioOutputrenameOutputRequestCommandParams.put("name",audioOutputrenameOutputRequestnameCommandParameterInfo); - + InteractionInfo audioOutputrenameOutputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AudioOutputCluster) cluster) @@ -4013,7 +4013,7 @@ public Map> getCommandMap() { commandArguments.get("index") , (String) commandArguments.get("name") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4023,14 +4023,14 @@ public Map> getCommandMap() { Map audioOutputselectOutputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); audioOutputselectOutputRequestCommandParams.put("index",audioOutputselectOutputRequestindexCommandParameterInfo); - + InteractionInfo audioOutputselectOutputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AudioOutputCluster) cluster) .selectOutputRequest((DefaultClusterCallback) callback , (Integer) commandArguments.get("index") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4042,14 +4042,14 @@ public Map> getCommandMap() { Map barrierControlbarrierControlGoToPercentCommandParams = new LinkedHashMap(); CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = new CommandParameterInfo("percentOpen", Integer.class); barrierControlbarrierControlGoToPercentCommandParams.put("percentOpen",barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); - + InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .barrierControlGoToPercent((DefaultClusterCallback) callback , (Integer) commandArguments.get("percentOpen") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4061,7 +4061,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .barrierControlStop((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4077,16 +4077,16 @@ public Map> getCommandMap() { Map bindingbindCommandParams = new LinkedHashMap(); CommandParameterInfo bindingbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); bindingbindCommandParams.put("nodeId",bindingbindnodeIdCommandParameterInfo); - + CommandParameterInfo bindingbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); bindingbindCommandParams.put("groupId",bindingbindgroupIdCommandParameterInfo); - + CommandParameterInfo bindingbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); bindingbindCommandParams.put("endpointId",bindingbindendpointIdCommandParameterInfo); - + CommandParameterInfo bindingbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); bindingbindCommandParams.put("clusterId",bindingbindclusterIdCommandParameterInfo); - + InteractionInfo bindingbindInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BindingCluster) cluster) @@ -4099,7 +4099,7 @@ public Map> getCommandMap() { commandArguments.get("endpointId") , (Long) commandArguments.get("clusterId") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4109,16 +4109,16 @@ public Map> getCommandMap() { Map bindingunbindCommandParams = new LinkedHashMap(); CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); bindingunbindCommandParams.put("nodeId",bindingunbindnodeIdCommandParameterInfo); - + CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); bindingunbindCommandParams.put("groupId",bindingunbindgroupIdCommandParameterInfo); - + CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); bindingunbindCommandParams.put("endpointId",bindingunbindendpointIdCommandParameterInfo); - + CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); bindingunbindCommandParams.put("clusterId",bindingunbindclusterIdCommandParameterInfo); - + InteractionInfo bindingunbindInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BindingCluster) cluster) @@ -4131,7 +4131,7 @@ public Map> getCommandMap() { commandArguments.get("endpointId") , (Long) commandArguments.get("clusterId") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4145,10 +4145,10 @@ public Map> getCommandMap() { Map bridgedActionsdisableActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsdisableActionCommandParams.put("actionID",bridgedActionsdisableActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsdisableActionCommandParams.put("invokeID",bridgedActionsdisableActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsdisableActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4157,7 +4157,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4167,13 +4167,13 @@ public Map> getCommandMap() { Map bridgedActionsdisableActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsdisableActionWithDurationCommandParams.put("actionID",bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsdisableActionWithDurationCommandParams.put("invokeID",bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionsdisableActionWithDurationCommandParams.put("duration",bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4184,7 +4184,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4194,10 +4194,10 @@ public Map> getCommandMap() { Map bridgedActionsenableActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsenableActionCommandParams.put("actionID",bridgedActionsenableActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsenableActionCommandParams.put("invokeID",bridgedActionsenableActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsenableActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4206,7 +4206,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4216,13 +4216,13 @@ public Map> getCommandMap() { Map bridgedActionsenableActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsenableActionWithDurationCommandParams.put("actionID",bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsenableActionWithDurationCommandParams.put("invokeID",bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionsenableActionWithDurationCommandParams.put("duration",bridgedActionsenableActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4233,7 +4233,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4243,10 +4243,10 @@ public Map> getCommandMap() { Map bridgedActionsinstantActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsinstantActionCommandParams.put("actionID",bridgedActionsinstantActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsinstantActionCommandParams.put("invokeID",bridgedActionsinstantActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsinstantActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4255,7 +4255,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4265,13 +4265,13 @@ public Map> getCommandMap() { Map bridgedActionsinstantActionWithTransitionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsinstantActionWithTransitionCommandParams.put("actionID",bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsinstantActionWithTransitionCommandParams.put("invokeID",bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); bridgedActionsinstantActionWithTransitionCommandParams.put("transitionTime",bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); - + InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4282,7 +4282,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4292,10 +4292,10 @@ public Map> getCommandMap() { Map bridgedActionspauseActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionspauseActionCommandParams.put("actionID",bridgedActionspauseActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionspauseActionCommandParams.put("invokeID",bridgedActionspauseActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionspauseActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4304,7 +4304,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4314,13 +4314,13 @@ public Map> getCommandMap() { Map bridgedActionspauseActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionspauseActionWithDurationCommandParams.put("actionID",bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionspauseActionWithDurationCommandParams.put("invokeID",bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionspauseActionWithDurationCommandParams.put("duration",bridgedActionspauseActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4331,7 +4331,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4341,10 +4341,10 @@ public Map> getCommandMap() { Map bridgedActionsresumeActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsresumeActionCommandParams.put("actionID",bridgedActionsresumeActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsresumeActionCommandParams.put("invokeID",bridgedActionsresumeActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsresumeActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4353,7 +4353,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4363,10 +4363,10 @@ public Map> getCommandMap() { Map bridgedActionsstartActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsstartActionCommandParams.put("actionID",bridgedActionsstartActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsstartActionCommandParams.put("invokeID",bridgedActionsstartActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsstartActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4375,7 +4375,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4385,13 +4385,13 @@ public Map> getCommandMap() { Map bridgedActionsstartActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsstartActionWithDurationCommandParams.put("actionID",bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsstartActionWithDurationCommandParams.put("invokeID",bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionsstartActionWithDurationCommandParams.put("duration",bridgedActionsstartActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4402,7 +4402,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4412,10 +4412,10 @@ public Map> getCommandMap() { Map bridgedActionsstopActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsstopActionCommandParams.put("actionID",bridgedActionsstopActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsstopActionCommandParams.put("invokeID",bridgedActionsstopActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsstopActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4424,7 +4424,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4438,10 +4438,10 @@ public Map> getCommandMap() { Map channelchangeChannelByNumberRequestCommandParams = new LinkedHashMap(); CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = new CommandParameterInfo("majorNumber", Integer.class); channelchangeChannelByNumberRequestCommandParams.put("majorNumber",channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); - + CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = new CommandParameterInfo("minorNumber", Integer.class); channelchangeChannelByNumberRequestCommandParams.put("minorNumber",channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); - + InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ChannelCluster) cluster) @@ -4450,7 +4450,7 @@ public Map> getCommandMap() { commandArguments.get("majorNumber") , (Integer) commandArguments.get("minorNumber") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4460,14 +4460,14 @@ public Map> getCommandMap() { Map channelchangeChannelRequestCommandParams = new LinkedHashMap(); CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = new CommandParameterInfo("match", String.class); channelchangeChannelRequestCommandParams.put("match",channelchangeChannelRequestmatchCommandParameterInfo); - + InteractionInfo channelchangeChannelRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ChannelCluster) cluster) .changeChannelRequest((ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback , (String) commandArguments.get("match") - + ); }, () -> new DelegatedChangeChannelResponseCallback(), @@ -4477,14 +4477,14 @@ public Map> getCommandMap() { Map channelskipChannelRequestCommandParams = new LinkedHashMap(); CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = new CommandParameterInfo("count", Integer.class); channelskipChannelRequestCommandParams.put("count",channelskipChannelRequestcountCommandParameterInfo); - + InteractionInfo channelskipChannelRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ChannelCluster) cluster) .skipChannelRequest((DefaultClusterCallback) callback , (Integer) commandArguments.get("count") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4496,25 +4496,25 @@ public Map> getCommandMap() { Map colorControlcolorLoopSetCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = new CommandParameterInfo("updateFlags", Integer.class); colorControlcolorLoopSetCommandParams.put("updateFlags",colorControlcolorLoopSetupdateFlagsCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = new CommandParameterInfo("action", Integer.class); colorControlcolorLoopSetCommandParams.put("action",colorControlcolorLoopSetactionCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); colorControlcolorLoopSetCommandParams.put("direction",colorControlcolorLoopSetdirectionCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = new CommandParameterInfo("time", Integer.class); colorControlcolorLoopSetCommandParams.put("time",colorControlcolorLoopSettimeCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = new CommandParameterInfo("startHue", Integer.class); colorControlcolorLoopSetCommandParams.put("startHue",colorControlcolorLoopSetstartHueCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlcolorLoopSetCommandParams.put("optionsMask",colorControlcolorLoopSetoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlcolorLoopSetCommandParams.put("optionsOverride",colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlcolorLoopSetInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4533,7 +4533,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4543,16 +4543,16 @@ public Map> getCommandMap() { Map colorControlenhancedMoveHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlenhancedMoveHueCommandParams.put("moveMode",colorControlenhancedMoveHuemoveModeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlenhancedMoveHueCommandParams.put("rate",colorControlenhancedMoveHuerateCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedMoveHueCommandParams.put("optionsMask",colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedMoveHueCommandParams.put("optionsOverride",colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedMoveHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4565,7 +4565,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4575,19 +4575,19 @@ public Map> getCommandMap() { Map colorControlenhancedMoveToHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); colorControlenhancedMoveToHueCommandParams.put("enhancedHue",colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); colorControlenhancedMoveToHueCommandParams.put("direction",colorControlenhancedMoveToHuedirectionCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlenhancedMoveToHueCommandParams.put("transitionTime",colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedMoveToHueCommandParams.put("optionsMask",colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedMoveToHueCommandParams.put("optionsOverride",colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedMoveToHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4602,7 +4602,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4612,19 +4612,19 @@ public Map> getCommandMap() { Map colorControlenhancedMoveToHueAndSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("enhancedHue",colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("saturation",colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("transitionTime",colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsMask",colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4639,7 +4639,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4649,19 +4649,19 @@ public Map> getCommandMap() { Map colorControlenhancedStepHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlenhancedStepHueCommandParams.put("stepMode",colorControlenhancedStepHuestepModeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlenhancedStepHueCommandParams.put("stepSize",colorControlenhancedStepHuestepSizeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlenhancedStepHueCommandParams.put("transitionTime",colorControlenhancedStepHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedStepHueCommandParams.put("optionsMask",colorControlenhancedStepHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedStepHueCommandParams.put("optionsOverride",colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedStepHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4676,7 +4676,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4686,16 +4686,16 @@ public Map> getCommandMap() { Map colorControlmoveColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = new CommandParameterInfo("rateX", Integer.class); colorControlmoveColorCommandParams.put("rateX",colorControlmoveColorrateXCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = new CommandParameterInfo("rateY", Integer.class); colorControlmoveColorCommandParams.put("rateY",colorControlmoveColorrateYCommandParameterInfo); - + CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveColorCommandParams.put("optionsMask",colorControlmoveColoroptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveColorCommandParams.put("optionsOverride",colorControlmoveColoroptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveColorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4708,7 +4708,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4718,22 +4718,22 @@ public Map> getCommandMap() { Map colorControlmoveColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlmoveColorTemperatureCommandParams.put("moveMode",colorControlmoveColorTemperaturemoveModeCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlmoveColorTemperatureCommandParams.put("rate",colorControlmoveColorTemperaturerateCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveColorTemperatureCommandParams.put("optionsMask",colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveColorTemperatureCommandParams.put("optionsOverride",colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveColorTemperatureInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4750,7 +4750,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4760,16 +4760,16 @@ public Map> getCommandMap() { Map colorControlmoveHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlmoveHueCommandParams.put("moveMode",colorControlmoveHuemoveModeCommandParameterInfo); - + CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlmoveHueCommandParams.put("rate",colorControlmoveHuerateCommandParameterInfo); - + CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveHueCommandParams.put("optionsMask",colorControlmoveHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveHueCommandParams.put("optionsOverride",colorControlmoveHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4782,7 +4782,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4792,16 +4792,16 @@ public Map> getCommandMap() { Map colorControlmoveSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlmoveSaturationCommandParams.put("moveMode",colorControlmoveSaturationmoveModeCommandParameterInfo); - + CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlmoveSaturationCommandParams.put("rate",colorControlmoveSaturationrateCommandParameterInfo); - + CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveSaturationCommandParams.put("optionsMask",colorControlmoveSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveSaturationCommandParams.put("optionsOverride",colorControlmoveSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4814,7 +4814,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4824,19 +4824,19 @@ public Map> getCommandMap() { Map colorControlmoveToColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = new CommandParameterInfo("colorX", Integer.class); colorControlmoveToColorCommandParams.put("colorX",colorControlmoveToColorcolorXCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = new CommandParameterInfo("colorY", Integer.class); colorControlmoveToColorCommandParams.put("colorY",colorControlmoveToColorcolorYCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToColorCommandParams.put("transitionTime",colorControlmoveToColortransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToColorCommandParams.put("optionsMask",colorControlmoveToColoroptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToColorCommandParams.put("optionsOverride",colorControlmoveToColoroptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToColorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4851,7 +4851,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4861,16 +4861,16 @@ public Map> getCommandMap() { Map colorControlmoveToColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = new CommandParameterInfo("colorTemperature", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("colorTemperature",colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("transitionTime",colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("optionsMask",colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("optionsOverride",colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4883,7 +4883,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4893,19 +4893,19 @@ public Map> getCommandMap() { Map colorControlmoveToHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); colorControlmoveToHueCommandParams.put("hue",colorControlmoveToHuehueCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); colorControlmoveToHueCommandParams.put("direction",colorControlmoveToHuedirectionCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToHueCommandParams.put("transitionTime",colorControlmoveToHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToHueCommandParams.put("optionsMask",colorControlmoveToHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToHueCommandParams.put("optionsOverride",colorControlmoveToHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4920,7 +4920,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4930,19 +4930,19 @@ public Map> getCommandMap() { Map colorControlmoveToHueAndSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("hue",colorControlmoveToHueAndSaturationhueCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("saturation",colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("transitionTime",colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("optionsMask",colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4957,7 +4957,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4967,16 +4967,16 @@ public Map> getCommandMap() { Map colorControlmoveToSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); colorControlmoveToSaturationCommandParams.put("saturation",colorControlmoveToSaturationsaturationCommandParameterInfo); - + CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToSaturationCommandParams.put("transitionTime",colorControlmoveToSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToSaturationCommandParams.put("optionsMask",colorControlmoveToSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToSaturationCommandParams.put("optionsOverride",colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4989,7 +4989,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4999,19 +4999,19 @@ public Map> getCommandMap() { Map colorControlstepColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = new CommandParameterInfo("stepX", Integer.class); colorControlstepColorCommandParams.put("stepX",colorControlstepColorstepXCommandParameterInfo); - + CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = new CommandParameterInfo("stepY", Integer.class); colorControlstepColorCommandParams.put("stepY",colorControlstepColorstepYCommandParameterInfo); - + CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepColorCommandParams.put("transitionTime",colorControlstepColortransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepColorCommandParams.put("optionsMask",colorControlstepColoroptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepColorCommandParams.put("optionsOverride",colorControlstepColoroptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepColorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5026,7 +5026,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5036,25 +5036,25 @@ public Map> getCommandMap() { Map colorControlstepColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlstepColorTemperatureCommandParams.put("stepMode",colorControlstepColorTemperaturestepModeCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlstepColorTemperatureCommandParams.put("stepSize",colorControlstepColorTemperaturestepSizeCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepColorTemperatureCommandParams.put("transitionTime",colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); colorControlstepColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); colorControlstepColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepColorTemperatureCommandParams.put("optionsMask",colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepColorTemperatureCommandParams.put("optionsOverride",colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepColorTemperatureInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5073,7 +5073,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5083,19 +5083,19 @@ public Map> getCommandMap() { Map colorControlstepHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlstepHueCommandParams.put("stepMode",colorControlstepHuestepModeCommandParameterInfo); - + CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlstepHueCommandParams.put("stepSize",colorControlstepHuestepSizeCommandParameterInfo); - + CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepHueCommandParams.put("transitionTime",colorControlstepHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepHueCommandParams.put("optionsMask",colorControlstepHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepHueCommandParams.put("optionsOverride",colorControlstepHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5110,7 +5110,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5120,19 +5120,19 @@ public Map> getCommandMap() { Map colorControlstepSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlstepSaturationCommandParams.put("stepMode",colorControlstepSaturationstepModeCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlstepSaturationCommandParams.put("stepSize",colorControlstepSaturationstepSizeCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepSaturationCommandParams.put("transitionTime",colorControlstepSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepSaturationCommandParams.put("optionsMask",colorControlstepSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepSaturationCommandParams.put("optionsOverride",colorControlstepSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5147,7 +5147,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5157,10 +5157,10 @@ public Map> getCommandMap() { Map colorControlstopMoveStepCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstopMoveStepCommandParams.put("optionsMask",colorControlstopMoveStepoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstopMoveStepCommandParams.put("optionsOverride",colorControlstopMoveStepoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstopMoveStepInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5169,7 +5169,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5181,10 +5181,10 @@ public Map> getCommandMap() { Map contentLauncherlaunchContentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = new CommandParameterInfo("autoPlay", Boolean.class); contentLauncherlaunchContentRequestCommandParams.put("autoPlay",contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); - + CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); contentLauncherlaunchContentRequestCommandParams.put("data",contentLauncherlaunchContentRequestdataCommandParameterInfo); - + InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ContentLauncherCluster) cluster) @@ -5195,7 +5195,7 @@ public Map> getCommandMap() { commandArguments.get("data") , (ArrayList) commandArguments.get("search") - + ); }, () -> new DelegatedLaunchResponseCallback(), @@ -5205,10 +5205,10 @@ public Map> getCommandMap() { Map contentLauncherlaunchURLRequestCommandParams = new LinkedHashMap(); CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = new CommandParameterInfo("contentURL", String.class); contentLauncherlaunchURLRequestCommandParams.put("contentURL",contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); - + CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = new CommandParameterInfo("displayString", String.class); contentLauncherlaunchURLRequestCommandParams.put("displayString",contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); - + InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ContentLauncherCluster) cluster) @@ -5219,7 +5219,7 @@ public Map> getCommandMap() { commandArguments.get("displayString") , (ChipStructs.ContentLauncherClusterBrandingInformation) commandArguments.get("brandingInformation") - + ); }, () -> new DelegatedLaunchResponseCallback(), @@ -5233,13 +5233,13 @@ public Map> getCommandMap() { Map diagnosticLogsretrieveLogsRequestCommandParams = new LinkedHashMap(); CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = new CommandParameterInfo("intent", Integer.class); diagnosticLogsretrieveLogsRequestCommandParams.put("intent",diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); - + CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = new CommandParameterInfo("requestedProtocol", Integer.class); diagnosticLogsretrieveLogsRequestCommandParams.put("requestedProtocol",diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); - + CommandParameterInfo diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = new CommandParameterInfo("transferFileDesignator", byte[].class); diagnosticLogsretrieveLogsRequestCommandParams.put("transferFileDesignator",diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); - + InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DiagnosticLogsCluster) cluster) @@ -5250,7 +5250,7 @@ public Map> getCommandMap() { commandArguments.get("requestedProtocol") , (byte[]) commandArguments.get("transferFileDesignator") - + ); }, () -> new DelegatedRetrieveLogsResponseCallback(), @@ -5276,7 +5276,7 @@ public Map> getCommandMap() { Map doorLockclearUserCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockclearUserCommandParams.put("userIndex",doorLockclearUseruserIndexCommandParameterInfo); - + InteractionInfo doorLockclearUserInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5293,10 +5293,10 @@ public Map> getCommandMap() { Map doorLockclearWeekDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); doorLockclearWeekDayScheduleCommandParams.put("weekDayIndex",doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockclearWeekDayScheduleCommandParams.put("userIndex",doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5305,7 +5305,7 @@ public Map> getCommandMap() { commandArguments.get("weekDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5315,10 +5315,10 @@ public Map> getCommandMap() { Map doorLockclearYearDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); doorLockclearYearDayScheduleCommandParams.put("yearDayIndex",doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockclearYearDayScheduleCommandParams.put("userIndex",doorLockclearYearDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockclearYearDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5327,7 +5327,7 @@ public Map> getCommandMap() { commandArguments.get("yearDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5341,7 +5341,7 @@ public Map> getCommandMap() { .getCredentialStatus((ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback , (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential") - + ); }, () -> new DelegatedGetCredentialStatusResponseCallback(), @@ -5351,14 +5351,14 @@ public Map> getCommandMap() { Map doorLockgetUserCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockgetUserCommandParams.put("userIndex",doorLockgetUseruserIndexCommandParameterInfo); - + InteractionInfo doorLockgetUserInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .getUser((ChipClusters.DoorLockCluster.GetUserResponseCallback) callback , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedGetUserResponseCallback(), @@ -5368,10 +5368,10 @@ public Map> getCommandMap() { Map doorLockgetWeekDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); doorLockgetWeekDayScheduleCommandParams.put("weekDayIndex",doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockgetWeekDayScheduleCommandParams.put("userIndex",doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5380,7 +5380,7 @@ public Map> getCommandMap() { commandArguments.get("weekDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedGetWeekDayScheduleResponseCallback(), @@ -5390,10 +5390,10 @@ public Map> getCommandMap() { Map doorLockgetYearDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); doorLockgetYearDayScheduleCommandParams.put("yearDayIndex",doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockgetYearDayScheduleCommandParams.put("userIndex",doorLockgetYearDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockgetYearDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5402,7 +5402,7 @@ public Map> getCommandMap() { commandArguments.get("yearDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedGetYearDayScheduleResponseCallback(), @@ -5412,7 +5412,7 @@ public Map> getCommandMap() { Map doorLocklockDoorCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); doorLocklockDoorCommandParams.put("pinCode",doorLocklockDoorpinCodeCommandParameterInfo); - + InteractionInfo doorLocklockDoorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5429,19 +5429,19 @@ public Map> getCommandMap() { Map doorLocksetCredentialCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); doorLocksetCredentialCommandParams.put("operationType",doorLocksetCredentialoperationTypeCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = new CommandParameterInfo("credentialData", byte[].class); doorLocksetCredentialCommandParams.put("credentialData",doorLocksetCredentialcredentialDataCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetCredentialCommandParams.put("userIndex",doorLocksetCredentialuserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); doorLocksetCredentialCommandParams.put("userStatus",doorLocksetCredentialuserStatusCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); doorLocksetCredentialCommandParams.put("userType",doorLocksetCredentialuserTypeCommandParameterInfo); - + InteractionInfo doorLocksetCredentialInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5468,25 +5468,25 @@ public Map> getCommandMap() { Map doorLocksetUserCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); doorLocksetUserCommandParams.put("operationType",doorLocksetUseroperationTypeCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetUserCommandParams.put("userIndex",doorLocksetUseruserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = new CommandParameterInfo("userName", String.class); doorLocksetUserCommandParams.put("userName",doorLocksetUseruserNameCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = new CommandParameterInfo("userUniqueId", Long.class); doorLocksetUserCommandParams.put("userUniqueId",doorLocksetUseruserUniqueIdCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); doorLocksetUserCommandParams.put("userStatus",doorLocksetUseruserStatusCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); doorLocksetUserCommandParams.put("userType",doorLocksetUseruserTypeCommandParameterInfo); - + CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = new CommandParameterInfo("credentialRule", Integer.class); doorLocksetUserCommandParams.put("credentialRule",doorLocksetUsercredentialRuleCommandParameterInfo); - + InteractionInfo doorLocksetUserInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5515,25 +5515,25 @@ public Map> getCommandMap() { Map doorLocksetWeekDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("weekDayIndex",doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("userIndex",doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = new CommandParameterInfo("daysMask", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("daysMask",doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = new CommandParameterInfo("startHour", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("startHour",doorLocksetWeekDaySchedulestartHourCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = new CommandParameterInfo("startMinute", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("startMinute",doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = new CommandParameterInfo("endHour", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("endHour",doorLocksetWeekDayScheduleendHourCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = new CommandParameterInfo("endMinute", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("endMinute",doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); - + InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5552,7 +5552,7 @@ public Map> getCommandMap() { commandArguments.get("endHour") , (Integer) commandArguments.get("endMinute") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5562,16 +5562,16 @@ public Map> getCommandMap() { Map doorLocksetYearDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); doorLocksetYearDayScheduleCommandParams.put("yearDayIndex",doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetYearDayScheduleCommandParams.put("userIndex",doorLocksetYearDayScheduleuserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = new CommandParameterInfo("localStartTime", Long.class); doorLocksetYearDayScheduleCommandParams.put("localStartTime",doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); - + CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = new CommandParameterInfo("localEndTime", Long.class); doorLocksetYearDayScheduleCommandParams.put("localEndTime",doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); - + InteractionInfo doorLocksetYearDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5584,7 +5584,7 @@ public Map> getCommandMap() { commandArguments.get("localStartTime") , (Long) commandArguments.get("localEndTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5594,7 +5594,7 @@ public Map> getCommandMap() { Map doorLockunlockDoorCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); doorLockunlockDoorCommandParams.put("pinCode",doorLockunlockDoorpinCodeCommandParameterInfo); - + InteractionInfo doorLockunlockDoorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5611,10 +5611,10 @@ public Map> getCommandMap() { Map doorLockunlockWithTimeoutCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = new CommandParameterInfo("timeout", Integer.class); doorLockunlockWithTimeoutCommandParams.put("timeout",doorLockunlockWithTimeouttimeoutCommandParameterInfo); - + CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); doorLockunlockWithTimeoutCommandParams.put("pinCode",doorLockunlockWithTimeoutpinCodeCommandParameterInfo); - + InteractionInfo doorLockunlockWithTimeoutInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5639,7 +5639,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .resetCounts((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5655,13 +5655,13 @@ public Map> getCommandMap() { Map generalCommissioningarmFailSafeCommandParams = new LinkedHashMap(); CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = new CommandParameterInfo("expiryLengthSeconds", Integer.class); generalCommissioningarmFailSafeCommandParams.put("expiryLengthSeconds",generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); - + CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); generalCommissioningarmFailSafeCommandParams.put("breadcrumb",generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); - + CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); generalCommissioningarmFailSafeCommandParams.put("timeoutMs",generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); - + InteractionInfo generalCommissioningarmFailSafeInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) @@ -5672,7 +5672,7 @@ public Map> getCommandMap() { commandArguments.get("breadcrumb") , (Long) commandArguments.get("timeoutMs") - + ); }, () -> new DelegatedArmFailSafeResponseCallback(), @@ -5684,7 +5684,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) .commissioningComplete((ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback) callback - + ); }, () -> new DelegatedCommissioningCompleteResponseCallback(), @@ -5694,16 +5694,16 @@ public Map> getCommandMap() { Map generalCommissioningsetRegulatoryConfigCommandParams = new LinkedHashMap(); CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = new CommandParameterInfo("location", Integer.class); generalCommissioningsetRegulatoryConfigCommandParams.put("location",generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); - + CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = new CommandParameterInfo("countryCode", String.class); generalCommissioningsetRegulatoryConfigCommandParams.put("countryCode",generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); - + CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); generalCommissioningsetRegulatoryConfigCommandParams.put("breadcrumb",generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); - + CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); generalCommissioningsetRegulatoryConfigCommandParams.put("timeoutMs",generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); - + InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) @@ -5716,7 +5716,7 @@ public Map> getCommandMap() { commandArguments.get("breadcrumb") , (Long) commandArguments.get("timeoutMs") - + ); }, () -> new DelegatedSetRegulatoryConfigResponseCallback(), @@ -5730,14 +5730,14 @@ public Map> getCommandMap() { Map groupKeyManagementkeySetReadCommandParams = new LinkedHashMap(); CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); groupKeyManagementkeySetReadCommandParams.put("groupKeySetID",groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); - + InteractionInfo groupKeyManagementkeySetReadInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .keySetRead((ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback , (Integer) commandArguments.get("groupKeySetID") - + ); }, () -> new DelegatedKeySetReadResponseCallback(), @@ -5747,14 +5747,14 @@ public Map> getCommandMap() { Map groupKeyManagementkeySetReadAllIndicesCommandParams = new LinkedHashMap(); CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = new CommandParameterInfo("groupKeySetIDs", ArrayList.class); groupKeyManagementkeySetReadAllIndicesCommandParams.put("groupKeySetIDs",groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); - + InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .keySetReadAllIndices((ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) callback , (ArrayList) commandArguments.get("groupKeySetIDs") - + ); }, () -> new DelegatedKeySetReadAllIndicesResponseCallback(), @@ -5764,14 +5764,14 @@ public Map> getCommandMap() { Map groupKeyManagementkeySetRemoveCommandParams = new LinkedHashMap(); CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); groupKeyManagementkeySetRemoveCommandParams.put("groupKeySetID",groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); - + InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .keySetRemove((DefaultClusterCallback) callback , (Integer) commandArguments.get("groupKeySetID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5785,7 +5785,7 @@ public Map> getCommandMap() { .keySetWrite((DefaultClusterCallback) callback , (ChipStructs.GroupKeyManagementClusterGroupKeySet) commandArguments.get("groupKeySet") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5797,10 +5797,10 @@ public Map> getCommandMap() { Map groupsaddGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsaddGroupCommandParams.put("groupId",groupsaddGroupgroupIdCommandParameterInfo); - + CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); groupsaddGroupCommandParams.put("groupName",groupsaddGroupgroupNameCommandParameterInfo); - + InteractionInfo groupsaddGroupInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) @@ -5809,7 +5809,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (String) commandArguments.get("groupName") - + ); }, () -> new DelegatedAddGroupResponseCallback(), @@ -5819,10 +5819,10 @@ public Map> getCommandMap() { Map groupsaddGroupIfIdentifyingCommandParams = new LinkedHashMap(); CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsaddGroupIfIdentifyingCommandParams.put("groupId",groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); - + CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); groupsaddGroupIfIdentifyingCommandParams.put("groupName",groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); - + InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) @@ -5831,7 +5831,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (String) commandArguments.get("groupName") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5841,14 +5841,14 @@ public Map> getCommandMap() { Map groupsgetGroupMembershipCommandParams = new LinkedHashMap(); CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = new CommandParameterInfo("groupList", ArrayList.class); groupsgetGroupMembershipCommandParams.put("groupList",groupsgetGroupMembershipgroupListCommandParameterInfo); - + InteractionInfo groupsgetGroupMembershipInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .getGroupMembership((ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback , (ArrayList) commandArguments.get("groupList") - + ); }, () -> new DelegatedGetGroupMembershipResponseCallback(), @@ -5860,7 +5860,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .removeAllGroups((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5870,14 +5870,14 @@ public Map> getCommandMap() { Map groupsremoveGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsremoveGroupCommandParams.put("groupId",groupsremoveGroupgroupIdCommandParameterInfo); - + InteractionInfo groupsremoveGroupInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .removeGroup((ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedRemoveGroupResponseCallback(), @@ -5887,14 +5887,14 @@ public Map> getCommandMap() { Map groupsviewGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsviewGroupCommandParams.put("groupId",groupsviewGroupgroupIdCommandParameterInfo); - + InteractionInfo groupsviewGroupInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .viewGroup((ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedViewGroupResponseCallback(), @@ -5906,14 +5906,14 @@ public Map> getCommandMap() { Map identifyidentifyCommandParams = new LinkedHashMap(); CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("identifyTime", Integer.class); identifyidentifyCommandParams.put("identifyTime",identifyidentifyidentifyTimeCommandParameterInfo); - + InteractionInfo identifyidentifyInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .identify((DefaultClusterCallback) callback , (Integer) commandArguments.get("identifyTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5925,7 +5925,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .identifyQuery((ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback - + ); }, () -> new DelegatedIdentifyQueryResponseCallback(), @@ -5935,10 +5935,10 @@ public Map> getCommandMap() { Map identifytriggerEffectCommandParams = new LinkedHashMap(); CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = new CommandParameterInfo("effectIdentifier", Integer.class); identifytriggerEffectCommandParams.put("effectIdentifier",identifytriggerEffecteffectIdentifierCommandParameterInfo); - + CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); identifytriggerEffectCommandParams.put("effectVariant",identifytriggerEffecteffectVariantCommandParameterInfo); - + InteractionInfo identifytriggerEffectInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) @@ -5947,7 +5947,7 @@ public Map> getCommandMap() { commandArguments.get("effectIdentifier") , (Integer) commandArguments.get("effectVariant") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5961,14 +5961,14 @@ public Map> getCommandMap() { Map keypadInputsendKeyRequestCommandParams = new LinkedHashMap(); CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = new CommandParameterInfo("keyCode", Integer.class); keypadInputsendKeyRequestCommandParams.put("keyCode",keypadInputsendKeyRequestkeyCodeCommandParameterInfo); - + InteractionInfo keypadInputsendKeyRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.KeypadInputCluster) cluster) .sendKeyRequest((ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback , (Integer) commandArguments.get("keyCode") - + ); }, () -> new DelegatedSendKeyResponseCallback(), @@ -5980,16 +5980,16 @@ public Map> getCommandMap() { Map levelControlmoveCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); levelControlmoveCommandParams.put("moveMode",levelControlmovemoveModeCommandParameterInfo); - + CommandParameterInfo levelControlmoverateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); levelControlmoveCommandParams.put("rate",levelControlmoverateCommandParameterInfo); - + CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlmoveCommandParams.put("optionMask",levelControlmoveoptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlmoveCommandParams.put("optionOverride",levelControlmoveoptionOverrideCommandParameterInfo); - + InteractionInfo levelControlmoveInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6002,7 +6002,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6012,16 +6012,16 @@ public Map> getCommandMap() { Map levelControlmoveToLevelCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); levelControlmoveToLevelCommandParams.put("level",levelControlmoveToLevellevelCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlmoveToLevelCommandParams.put("transitionTime",levelControlmoveToLeveltransitionTimeCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlmoveToLevelCommandParams.put("optionMask",levelControlmoveToLeveloptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlmoveToLevelCommandParams.put("optionOverride",levelControlmoveToLeveloptionOverrideCommandParameterInfo); - + InteractionInfo levelControlmoveToLevelInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6034,7 +6034,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6044,10 +6044,10 @@ public Map> getCommandMap() { Map levelControlmoveToLevelWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); levelControlmoveToLevelWithOnOffCommandParams.put("level",levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlmoveToLevelWithOnOffCommandParams.put("transitionTime",levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); - + InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6056,7 +6056,7 @@ public Map> getCommandMap() { commandArguments.get("level") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6066,10 +6066,10 @@ public Map> getCommandMap() { Map levelControlmoveWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); levelControlmoveWithOnOffCommandParams.put("moveMode",levelControlmoveWithOnOffmoveModeCommandParameterInfo); - + CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); levelControlmoveWithOnOffCommandParams.put("rate",levelControlmoveWithOnOffrateCommandParameterInfo); - + InteractionInfo levelControlmoveWithOnOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6078,7 +6078,7 @@ public Map> getCommandMap() { commandArguments.get("moveMode") , (Integer) commandArguments.get("rate") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6088,19 +6088,19 @@ public Map> getCommandMap() { Map levelControlstepCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstepstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); levelControlstepCommandParams.put("stepMode",levelControlstepstepModeCommandParameterInfo); - + CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); levelControlstepCommandParams.put("stepSize",levelControlstepstepSizeCommandParameterInfo); - + CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlstepCommandParams.put("transitionTime",levelControlsteptransitionTimeCommandParameterInfo); - + CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlstepCommandParams.put("optionMask",levelControlstepoptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlstepCommandParams.put("optionOverride",levelControlstepoptionOverrideCommandParameterInfo); - + InteractionInfo levelControlstepInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6115,7 +6115,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6125,13 +6125,13 @@ public Map> getCommandMap() { Map levelControlstepWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); levelControlstepWithOnOffCommandParams.put("stepMode",levelControlstepWithOnOffstepModeCommandParameterInfo); - + CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); levelControlstepWithOnOffCommandParams.put("stepSize",levelControlstepWithOnOffstepSizeCommandParameterInfo); - + CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlstepWithOnOffCommandParams.put("transitionTime",levelControlstepWithOnOfftransitionTimeCommandParameterInfo); - + InteractionInfo levelControlstepWithOnOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6142,7 +6142,7 @@ public Map> getCommandMap() { commandArguments.get("stepSize") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6152,10 +6152,10 @@ public Map> getCommandMap() { Map levelControlstopCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlstopCommandParams.put("optionMask",levelControlstopoptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlstopCommandParams.put("optionOverride",levelControlstopoptionOverrideCommandParameterInfo); - + InteractionInfo levelControlstopInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6164,7 +6164,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6176,7 +6176,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .stopWithOnOff((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6192,7 +6192,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.LowPowerCluster) cluster) .sleep((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6206,7 +6206,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .hideInputStatusRequest((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6216,10 +6216,10 @@ public Map> getCommandMap() { Map mediaInputrenameInputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); mediaInputrenameInputRequestCommandParams.put("index",mediaInputrenameInputRequestindexCommandParameterInfo); - + CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); mediaInputrenameInputRequestCommandParams.put("name",mediaInputrenameInputRequestnameCommandParameterInfo); - + InteractionInfo mediaInputrenameInputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) @@ -6228,7 +6228,7 @@ public Map> getCommandMap() { commandArguments.get("index") , (String) commandArguments.get("name") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6238,14 +6238,14 @@ public Map> getCommandMap() { Map mediaInputselectInputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); mediaInputselectInputRequestCommandParams.put("index",mediaInputselectInputRequestindexCommandParameterInfo); - + InteractionInfo mediaInputselectInputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .selectInputRequest((DefaultClusterCallback) callback , (Integer) commandArguments.get("index") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6257,7 +6257,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .showInputStatusRequest((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6271,7 +6271,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .fastForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6283,7 +6283,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .nextRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6295,7 +6295,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .pauseRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6307,7 +6307,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .playRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6319,7 +6319,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .previousRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6331,7 +6331,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .rewindRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6341,14 +6341,14 @@ public Map> getCommandMap() { Map mediaPlaybackseekRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = new CommandParameterInfo("position", Long.class); mediaPlaybackseekRequestCommandParams.put("position",mediaPlaybackseekRequestpositionCommandParameterInfo); - + InteractionInfo mediaPlaybackseekRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .seekRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback , (Long) commandArguments.get("position") - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6358,14 +6358,14 @@ public Map> getCommandMap() { Map mediaPlaybackskipBackwardRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); mediaPlaybackskipBackwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); - + InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .skipBackwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback , (Long) commandArguments.get("deltaPositionMilliseconds") - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6375,14 +6375,14 @@ public Map> getCommandMap() { Map mediaPlaybackskipForwardRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); mediaPlaybackskipForwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); - + InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .skipForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback , (Long) commandArguments.get("deltaPositionMilliseconds") - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6394,7 +6394,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .startOverRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6406,7 +6406,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .stopRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6418,14 +6418,14 @@ public Map> getCommandMap() { Map modeSelectchangeToModeCommandParams = new LinkedHashMap(); CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = new CommandParameterInfo("newMode", Integer.class); modeSelectchangeToModeCommandParams.put("newMode",modeSelectchangeToModenewModeCommandParameterInfo); - + InteractionInfo modeSelectchangeToModeInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ModeSelectCluster) cluster) .changeToMode((DefaultClusterCallback) callback , (Integer) commandArguments.get("newMode") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6437,10 +6437,10 @@ public Map> getCommandMap() { Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = new CommandParameterInfo("operationalDataset", byte[].class); networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("operationalDataset",networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); - + CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6449,7 +6449,7 @@ public Map> getCommandMap() { commandArguments.get("operationalDataset") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6459,13 +6459,13 @@ public Map> getCommandMap() { Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("ssid",networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); - + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = new CommandParameterInfo("credentials", byte[].class); networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("credentials",networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); - + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6476,7 +6476,7 @@ public Map> getCommandMap() { commandArguments.get("credentials") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6486,10 +6486,10 @@ public Map> getCommandMap() { Map networkCommissioningconnectNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); networkCommissioningconnectNetworkCommandParams.put("networkID",networkCommissioningconnectNetworknetworkIDCommandParameterInfo); - + CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningconnectNetworkCommandParams.put("breadcrumb",networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningconnectNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6498,7 +6498,7 @@ public Map> getCommandMap() { commandArguments.get("networkID") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedConnectNetworkResponseCallback(), @@ -6508,10 +6508,10 @@ public Map> getCommandMap() { Map networkCommissioningremoveNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); networkCommissioningremoveNetworkCommandParams.put("networkID",networkCommissioningremoveNetworknetworkIDCommandParameterInfo); - + CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningremoveNetworkCommandParams.put("breadcrumb",networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningremoveNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6520,7 +6520,7 @@ public Map> getCommandMap() { commandArguments.get("networkID") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6530,13 +6530,13 @@ public Map> getCommandMap() { Map networkCommissioningreorderNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); networkCommissioningreorderNetworkCommandParams.put("networkID",networkCommissioningreorderNetworknetworkIDCommandParameterInfo); - + CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = new CommandParameterInfo("networkIndex", Integer.class); networkCommissioningreorderNetworkCommandParams.put("networkIndex",networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); - + CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningreorderNetworkCommandParams.put("breadcrumb",networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningreorderNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6547,7 +6547,7 @@ public Map> getCommandMap() { commandArguments.get("networkIndex") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6557,10 +6557,10 @@ public Map> getCommandMap() { Map networkCommissioningscanNetworksCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); networkCommissioningscanNetworksCommandParams.put("ssid",networkCommissioningscanNetworksssidCommandParameterInfo); - + CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningscanNetworksCommandParams.put("breadcrumb",networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningscanNetworksInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6569,7 +6569,7 @@ public Map> getCommandMap() { commandArguments.get("ssid") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedScanNetworksResponseCallback(), @@ -6581,10 +6581,10 @@ public Map> getCommandMap() { Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("updateToken",otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = new CommandParameterInfo("newVersion", Long.class); otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("newVersion",otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) @@ -6593,7 +6593,7 @@ public Map> getCommandMap() { commandArguments.get("updateToken") , (Long) commandArguments.get("newVersion") - + ); }, () -> new DelegatedApplyUpdateResponseCallback(), @@ -6603,10 +6603,10 @@ public Map> getCommandMap() { Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("updateToken",otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("softwareVersion",otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) @@ -6615,7 +6615,7 @@ public Map> getCommandMap() { commandArguments.get("updateToken") , (Long) commandArguments.get("softwareVersion") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6625,28 +6625,28 @@ public Map> getCommandMap() { Map otaSoftwareUpdateProviderqueryImageCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("vendorId",otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = new CommandParameterInfo("productId", Integer.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("productId",otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("softwareVersion",otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = new CommandParameterInfo("protocolsSupported", ArrayList.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("protocolsSupported",otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = new CommandParameterInfo("hardwareVersion", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("hardwareVersion",otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = new CommandParameterInfo("location", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("location",otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = new CommandParameterInfo("requestorCanConsent", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("requestorCanConsent",otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = new CommandParameterInfo("metadataForProvider", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("metadataForProvider",otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) @@ -6667,7 +6667,7 @@ public Map> getCommandMap() { commandArguments.get("requestorCanConsent") , (Optional) commandArguments.get("metadataForProvider") - + ); }, () -> new DelegatedQueryImageResponseCallback(), @@ -6679,19 +6679,19 @@ public Map> getCommandMap() { Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = new CommandParameterInfo("providerNodeId", Long.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("providerNodeId",otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("vendorId",otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = new CommandParameterInfo("announcementReason", Integer.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("announcementReason",otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = new CommandParameterInfo("metadataForNode", Optional.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("metadataForNode",otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = new CommandParameterInfo("endpoint", Integer.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("endpoint",otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) @@ -6706,7 +6706,7 @@ public Map> getCommandMap() { commandArguments.get("metadataForNode") , (Integer) commandArguments.get("endpoint") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6722,7 +6722,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .off((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6732,10 +6732,10 @@ public Map> getCommandMap() { Map onOffoffWithEffectCommandParams = new LinkedHashMap(); CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = new CommandParameterInfo("effectId", Integer.class); onOffoffWithEffectCommandParams.put("effectId",onOffoffWithEffecteffectIdCommandParameterInfo); - + CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); onOffoffWithEffectCommandParams.put("effectVariant",onOffoffWithEffecteffectVariantCommandParameterInfo); - + InteractionInfo onOffoffWithEffectInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) @@ -6744,7 +6744,7 @@ public Map> getCommandMap() { commandArguments.get("effectId") , (Integer) commandArguments.get("effectVariant") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6756,7 +6756,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .on((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6768,7 +6768,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .onWithRecallGlobalScene((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6778,13 +6778,13 @@ public Map> getCommandMap() { Map onOffonWithTimedOffCommandParams = new LinkedHashMap(); CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = new CommandParameterInfo("onOffControl", Integer.class); onOffonWithTimedOffCommandParams.put("onOffControl",onOffonWithTimedOffonOffControlCommandParameterInfo); - + CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = new CommandParameterInfo("onTime", Integer.class); onOffonWithTimedOffCommandParams.put("onTime",onOffonWithTimedOffonTimeCommandParameterInfo); - + CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("offWaitTime", Integer.class); onOffonWithTimedOffCommandParams.put("offWaitTime",onOffonWithTimedOffoffWaitTimeCommandParameterInfo); - + InteractionInfo onOffonWithTimedOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) @@ -6795,7 +6795,7 @@ public Map> getCommandMap() { commandArguments.get("onTime") , (Integer) commandArguments.get("offWaitTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6807,7 +6807,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .toggle((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6821,19 +6821,19 @@ public Map> getCommandMap() { Map operationalCredentialsaddNOCCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); operationalCredentialsaddNOCCommandParams.put("NOCValue",operationalCredentialsaddNOCNOCValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); operationalCredentialsaddNOCCommandParams.put("ICACValue",operationalCredentialsaddNOCICACValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = new CommandParameterInfo("IPKValue", byte[].class); operationalCredentialsaddNOCCommandParams.put("IPKValue",operationalCredentialsaddNOCIPKValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = new CommandParameterInfo("caseAdminNode", Long.class); operationalCredentialsaddNOCCommandParams.put("caseAdminNode",operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = new CommandParameterInfo("adminVendorId", Integer.class); operationalCredentialsaddNOCCommandParams.put("adminVendorId",operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); - + InteractionInfo operationalCredentialsaddNOCInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) @@ -6848,7 +6848,7 @@ public Map> getCommandMap() { commandArguments.get("caseAdminNode") , (Integer) commandArguments.get("adminVendorId") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -6858,14 +6858,14 @@ public Map> getCommandMap() { Map operationalCredentialsaddTrustedRootCertificateCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = new CommandParameterInfo("rootCertificate", byte[].class); operationalCredentialsaddTrustedRootCertificateCommandParams.put("rootCertificate",operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); - + InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .addTrustedRootCertificate((DefaultClusterCallback) callback , (byte[]) commandArguments.get("rootCertificate") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6875,14 +6875,14 @@ public Map> getCommandMap() { Map operationalCredentialsattestationRequestCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = new CommandParameterInfo("attestationNonce", byte[].class); operationalCredentialsattestationRequestCommandParams.put("attestationNonce",operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); - + InteractionInfo operationalCredentialsattestationRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .attestationRequest((ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) callback , (byte[]) commandArguments.get("attestationNonce") - + ); }, () -> new DelegatedAttestationResponseCallback(), @@ -6892,14 +6892,14 @@ public Map> getCommandMap() { Map operationalCredentialscertificateChainRequestCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = new CommandParameterInfo("certificateType", Integer.class); operationalCredentialscertificateChainRequestCommandParams.put("certificateType",operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); - + InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .certificateChainRequest((ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) callback , (Integer) commandArguments.get("certificateType") - + ); }, () -> new DelegatedCertificateChainResponseCallback(), @@ -6909,14 +6909,14 @@ public Map> getCommandMap() { Map operationalCredentialsopCSRRequestCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = new CommandParameterInfo("CSRNonce", byte[].class); operationalCredentialsopCSRRequestCommandParams.put("CSRNonce",operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); - + InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .opCSRRequest((ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback , (byte[]) commandArguments.get("CSRNonce") - + ); }, () -> new DelegatedOpCSRResponseCallback(), @@ -6926,14 +6926,14 @@ public Map> getCommandMap() { Map operationalCredentialsremoveFabricCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = new CommandParameterInfo("fabricIndex", Integer.class); operationalCredentialsremoveFabricCommandParams.put("fabricIndex",operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); - + InteractionInfo operationalCredentialsremoveFabricInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .removeFabric((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback , (Integer) commandArguments.get("fabricIndex") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -6943,14 +6943,14 @@ public Map> getCommandMap() { Map operationalCredentialsremoveTrustedRootCertificateCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = new CommandParameterInfo("trustedRootIdentifier", byte[].class); operationalCredentialsremoveTrustedRootCertificateCommandParams.put("trustedRootIdentifier",operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); - + InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .removeTrustedRootCertificate((DefaultClusterCallback) callback , (byte[]) commandArguments.get("trustedRootIdentifier") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6960,14 +6960,14 @@ public Map> getCommandMap() { Map operationalCredentialsupdateFabricLabelCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = new CommandParameterInfo("label", String.class); operationalCredentialsupdateFabricLabelCommandParams.put("label",operationalCredentialsupdateFabricLabellabelCommandParameterInfo); - + InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .updateFabricLabel((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback , (String) commandArguments.get("label") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -6977,10 +6977,10 @@ public Map> getCommandMap() { Map operationalCredentialsupdateNOCCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); operationalCredentialsupdateNOCCommandParams.put("NOCValue",operationalCredentialsupdateNOCNOCValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); operationalCredentialsupdateNOCCommandParams.put("ICACValue",operationalCredentialsupdateNOCICACValueCommandParameterInfo); - + InteractionInfo operationalCredentialsupdateNOCInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) @@ -6989,7 +6989,7 @@ public Map> getCommandMap() { commandArguments.get("NOCValue") , (Optional) commandArguments.get("ICACValue") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -7011,16 +7011,16 @@ public Map> getCommandMap() { Map scenesaddSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesaddSceneCommandParams.put("groupId",scenesaddScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesaddSceneCommandParams.put("sceneId",scenesaddScenesceneIdCommandParameterInfo); - + CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); scenesaddSceneCommandParams.put("transitionTime",scenesaddScenetransitionTimeCommandParameterInfo); - + CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = new CommandParameterInfo("sceneName", String.class); scenesaddSceneCommandParams.put("sceneName",scenesaddScenesceneNameCommandParameterInfo); - + InteractionInfo scenesaddSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7035,7 +7035,7 @@ public Map> getCommandMap() { commandArguments.get("sceneName") , (ArrayList) commandArguments.get("extensionFieldSets") - + ); }, () -> new DelegatedAddSceneResponseCallback(), @@ -7045,14 +7045,14 @@ public Map> getCommandMap() { Map scenesgetSceneMembershipCommandParams = new LinkedHashMap(); CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesgetSceneMembershipCommandParams.put("groupId",scenesgetSceneMembershipgroupIdCommandParameterInfo); - + InteractionInfo scenesgetSceneMembershipInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .getSceneMembership((ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedGetSceneMembershipResponseCallback(), @@ -7062,13 +7062,13 @@ public Map> getCommandMap() { Map scenesrecallSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesrecallSceneCommandParams.put("groupId",scenesrecallScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesrecallSceneCommandParams.put("sceneId",scenesrecallScenesceneIdCommandParameterInfo); - + CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); scenesrecallSceneCommandParams.put("transitionTime",scenesrecallScenetransitionTimeCommandParameterInfo); - + InteractionInfo scenesrecallSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7079,7 +7079,7 @@ public Map> getCommandMap() { commandArguments.get("sceneId") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7089,14 +7089,14 @@ public Map> getCommandMap() { Map scenesremoveAllScenesCommandParams = new LinkedHashMap(); CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesremoveAllScenesCommandParams.put("groupId",scenesremoveAllScenesgroupIdCommandParameterInfo); - + InteractionInfo scenesremoveAllScenesInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .removeAllScenes((ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedRemoveAllScenesResponseCallback(), @@ -7106,10 +7106,10 @@ public Map> getCommandMap() { Map scenesremoveSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesremoveSceneCommandParams.put("groupId",scenesremoveScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesremoveSceneCommandParams.put("sceneId",scenesremoveScenesceneIdCommandParameterInfo); - + InteractionInfo scenesremoveSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7118,7 +7118,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (Integer) commandArguments.get("sceneId") - + ); }, () -> new DelegatedRemoveSceneResponseCallback(), @@ -7128,10 +7128,10 @@ public Map> getCommandMap() { Map scenesstoreSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesstoreSceneCommandParams.put("groupId",scenesstoreScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesstoreSceneCommandParams.put("sceneId",scenesstoreScenesceneIdCommandParameterInfo); - + InteractionInfo scenesstoreSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7140,7 +7140,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (Integer) commandArguments.get("sceneId") - + ); }, () -> new DelegatedStoreSceneResponseCallback(), @@ -7150,10 +7150,10 @@ public Map> getCommandMap() { Map scenesviewSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesviewSceneCommandParams.put("groupId",scenesviewScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesviewSceneCommandParams.put("sceneId",scenesviewScenesceneIdCommandParameterInfo); - + InteractionInfo scenesviewSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7162,7 +7162,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (Integer) commandArguments.get("sceneId") - + ); }, () -> new DelegatedViewSceneResponseCallback(), @@ -7176,7 +7176,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.SoftwareDiagnosticsCluster) cluster) .resetWatermarks((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7190,10 +7190,10 @@ public Map> getCommandMap() { Map targetNavigatornavigateTargetRequestCommandParams = new LinkedHashMap(); CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = new CommandParameterInfo("target", Integer.class); targetNavigatornavigateTargetRequestCommandParams.put("target",targetNavigatornavigateTargetRequesttargetCommandParameterInfo); - + CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); targetNavigatornavigateTargetRequestCommandParams.put("data",targetNavigatornavigateTargetRequestdataCommandParameterInfo); - + InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TargetNavigatorCluster) cluster) @@ -7202,7 +7202,7 @@ public Map> getCommandMap() { commandArguments.get("target") , (String) commandArguments.get("data") - + ); }, () -> new DelegatedNavigateTargetResponseCallback(), @@ -7220,7 +7220,7 @@ public Map> getCommandMap() { .simpleStructEchoRequest((ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback , (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1") - + ); }, () -> new DelegatedSimpleStructResponseCallback(), @@ -7232,7 +7232,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .test((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7242,10 +7242,10 @@ public Map> getCommandMap() { Map testClustertestAddArgumentsCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); testClustertestAddArgumentsCommandParams.put("arg1",testClustertestAddArgumentsarg1CommandParameterInfo); - + CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); testClustertestAddArgumentsCommandParams.put("arg2",testClustertestAddArgumentsarg2CommandParameterInfo); - + InteractionInfo testClustertestAddArgumentsInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) @@ -7254,7 +7254,7 @@ public Map> getCommandMap() { commandArguments.get("arg1") , (Integer) commandArguments.get("arg2") - + ); }, () -> new DelegatedTestAddArgumentsResponseCallback(), @@ -7264,13 +7264,13 @@ public Map> getCommandMap() { Map testClustertestEmitTestEventRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); testClustertestEmitTestEventRequestCommandParams.put("arg1",testClustertestEmitTestEventRequestarg1CommandParameterInfo); - + CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); testClustertestEmitTestEventRequestCommandParams.put("arg2",testClustertestEmitTestEventRequestarg2CommandParameterInfo); - + CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = new CommandParameterInfo("arg3", Boolean.class); testClustertestEmitTestEventRequestCommandParams.put("arg3",testClustertestEmitTestEventRequestarg3CommandParameterInfo); - + InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) @@ -7281,7 +7281,7 @@ public Map> getCommandMap() { commandArguments.get("arg2") , (Boolean) commandArguments.get("arg3") - + ); }, () -> new DelegatedTestEmitTestEventResponseCallback(), @@ -7291,10 +7291,10 @@ public Map> getCommandMap() { Map testClustertestEnumsRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); testClustertestEnumsRequestCommandParams.put("arg1",testClustertestEnumsRequestarg1CommandParameterInfo); - + CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); testClustertestEnumsRequestCommandParams.put("arg2",testClustertestEnumsRequestarg2CommandParameterInfo); - + InteractionInfo testClustertestEnumsRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) @@ -7303,7 +7303,7 @@ public Map> getCommandMap() { commandArguments.get("arg1") , (Integer) commandArguments.get("arg2") - + ); }, () -> new DelegatedTestEnumsResponseCallback(), @@ -7313,14 +7313,14 @@ public Map> getCommandMap() { Map testClustertestListInt8UArgumentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); testClustertestListInt8UArgumentRequestCommandParams.put("arg1",testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testListInt8UArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7330,14 +7330,14 @@ public Map> getCommandMap() { Map testClustertestListInt8UReverseRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); testClustertestListInt8UReverseRequestCommandParams.put("arg1",testClustertestListInt8UReverseRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testListInt8UReverseRequest((ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedTestListInt8UReverseResponseCallback(), @@ -7351,7 +7351,7 @@ public Map> getCommandMap() { .testListNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7365,7 +7365,7 @@ public Map> getCommandMap() { .testListStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7379,7 +7379,7 @@ public Map> getCommandMap() { .testNestedStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ChipStructs.TestClusterClusterNestedStruct) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7393,7 +7393,7 @@ public Map> getCommandMap() { .testNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ChipStructs.TestClusterClusterNestedStructList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7405,7 +7405,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testNotHandled((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7415,14 +7415,14 @@ public Map> getCommandMap() { Map testClustertestNullableOptionalRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); testClustertestNullableOptionalRequestCommandParams.put("arg1",testClustertestNullableOptionalRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testNullableOptionalRequest((ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) callback , (Optional) commandArguments.get("arg1") - + ); }, () -> new DelegatedTestNullableOptionalResponseCallback(), @@ -7432,14 +7432,14 @@ public Map> getCommandMap() { Map testClustertestSimpleOptionalArgumentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); testClustertestSimpleOptionalArgumentRequestCommandParams.put("arg1",testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testSimpleOptionalArgumentRequest((DefaultClusterCallback) callback , (Optional) commandArguments.get("arg1") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7451,7 +7451,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testSpecific((ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback - + ); }, () -> new DelegatedTestSpecificResponseCallback(), @@ -7465,7 +7465,7 @@ public Map> getCommandMap() { .testStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7477,7 +7477,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testUnknownCommand((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7503,7 +7503,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .clearWeeklySchedule((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7515,7 +7515,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .getRelayStatusLog((ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback - + ); }, () -> new DelegatedGetRelayStatusLogResponseCallback(), @@ -7525,10 +7525,10 @@ public Map> getCommandMap() { Map thermostatgetWeeklyScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = new CommandParameterInfo("daysToReturn", Integer.class); thermostatgetWeeklyScheduleCommandParams.put("daysToReturn",thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); - + CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = new CommandParameterInfo("modeToReturn", Integer.class); thermostatgetWeeklyScheduleCommandParams.put("modeToReturn",thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); - + InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) @@ -7537,7 +7537,7 @@ public Map> getCommandMap() { commandArguments.get("daysToReturn") , (Integer) commandArguments.get("modeToReturn") - + ); }, () -> new DelegatedGetWeeklyScheduleResponseCallback(), @@ -7547,16 +7547,16 @@ public Map> getCommandMap() { Map thermostatsetWeeklyScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); thermostatsetWeeklyScheduleCommandParams.put("numberOfTransitionsForSequence",thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); - + CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = new CommandParameterInfo("dayOfWeekForSequence", Integer.class); thermostatsetWeeklyScheduleCommandParams.put("dayOfWeekForSequence",thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); - + CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = new CommandParameterInfo("modeForSequence", Integer.class); thermostatsetWeeklyScheduleCommandParams.put("modeForSequence",thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); - + CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = new CommandParameterInfo("payload", ArrayList.class); thermostatsetWeeklyScheduleCommandParams.put("payload",thermostatsetWeeklySchedulepayloadCommandParameterInfo); - + InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) @@ -7569,7 +7569,7 @@ public Map> getCommandMap() { commandArguments.get("modeForSequence") , (ArrayList) commandArguments.get("payload") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7579,10 +7579,10 @@ public Map> getCommandMap() { Map thermostatsetpointRaiseLowerCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = new CommandParameterInfo("mode", Integer.class); thermostatsetpointRaiseLowerCommandParams.put("mode",thermostatsetpointRaiseLowermodeCommandParameterInfo); - + CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = new CommandParameterInfo("amount", Integer.class); thermostatsetpointRaiseLowerCommandParams.put("amount",thermostatsetpointRaiseLoweramountCommandParameterInfo); - + InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) @@ -7591,7 +7591,7 @@ public Map> getCommandMap() { commandArguments.get("mode") , (Integer) commandArguments.get("amount") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7607,7 +7607,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .resetCounts((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7629,7 +7629,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .resetCounts((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7643,7 +7643,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .downOrClose((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7653,10 +7653,10 @@ public Map> getCommandMap() { Map windowCoveringgoToLiftPercentageCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = new CommandParameterInfo("liftPercentageValue", Integer.class); windowCoveringgoToLiftPercentageCommandParams.put("liftPercentageValue",windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); - + CommandParameterInfo windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = new CommandParameterInfo("liftPercent100thsValue", Integer.class); windowCoveringgoToLiftPercentageCommandParams.put("liftPercent100thsValue",windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) @@ -7665,7 +7665,7 @@ public Map> getCommandMap() { commandArguments.get("liftPercentageValue") , (Integer) commandArguments.get("liftPercent100thsValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7675,14 +7675,14 @@ public Map> getCommandMap() { Map windowCoveringgoToLiftValueCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = new CommandParameterInfo("liftValue", Integer.class); windowCoveringgoToLiftValueCommandParams.put("liftValue",windowCoveringgoToLiftValueliftValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToLiftValueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .goToLiftValue((DefaultClusterCallback) callback , (Integer) commandArguments.get("liftValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7692,10 +7692,10 @@ public Map> getCommandMap() { Map windowCoveringgoToTiltPercentageCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = new CommandParameterInfo("tiltPercentageValue", Integer.class); windowCoveringgoToTiltPercentageCommandParams.put("tiltPercentageValue",windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); - + CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = new CommandParameterInfo("tiltPercent100thsValue", Integer.class); windowCoveringgoToTiltPercentageCommandParams.put("tiltPercent100thsValue",windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) @@ -7704,7 +7704,7 @@ public Map> getCommandMap() { commandArguments.get("tiltPercentageValue") , (Integer) commandArguments.get("tiltPercent100thsValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7714,14 +7714,14 @@ public Map> getCommandMap() { Map windowCoveringgoToTiltValueCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = new CommandParameterInfo("tiltValue", Integer.class); windowCoveringgoToTiltValueCommandParams.put("tiltValue",windowCoveringgoToTiltValuetiltValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToTiltValueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .goToTiltValue((DefaultClusterCallback) callback , (Integer) commandArguments.get("tiltValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7733,7 +7733,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .stopMotion((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7745,7 +7745,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .upOrOpen((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7757,4 +7757,3 @@ public Map> getCommandMap() { } } - diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java index 48ec9330a3b2f2..e433d2ce7db37d 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java @@ -8070,4 +8070,3 @@ public Map> getReadAttributeMap() { return readAttributeMap; } } - diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java index a70c5b71a4a9de..e701c60d01ca31 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java @@ -53,7 +53,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -69,7 +69,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -85,7 +85,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -103,7 +103,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -119,7 +119,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -147,7 +147,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -163,7 +163,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -179,7 +179,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -195,7 +195,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -211,7 +211,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -227,7 +227,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -243,7 +243,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -259,7 +259,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -275,7 +275,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -291,7 +291,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -307,7 +307,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -323,7 +323,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -339,7 +339,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -357,7 +357,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -379,7 +379,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -395,7 +395,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -411,7 +411,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -427,7 +427,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -443,7 +443,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -459,7 +459,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -475,7 +475,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -501,7 +501,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -525,7 +525,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -547,7 +547,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -563,7 +563,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -579,7 +579,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -595,7 +595,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -611,7 +611,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -627,7 +627,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -643,7 +643,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -661,7 +661,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -685,7 +685,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -703,7 +703,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -727,7 +727,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -743,7 +743,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -759,7 +759,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -777,7 +777,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -803,7 +803,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -819,7 +819,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -835,7 +835,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -851,7 +851,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -881,7 +881,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -897,7 +897,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -913,7 +913,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -929,7 +929,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -945,7 +945,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -961,7 +961,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -977,7 +977,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -993,7 +993,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1009,7 +1009,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1025,7 +1025,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1041,7 +1041,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1057,7 +1057,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1073,7 +1073,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1089,7 +1089,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1105,7 +1105,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1121,7 +1121,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1137,7 +1137,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1153,7 +1153,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1169,7 +1169,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1185,7 +1185,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1201,7 +1201,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1217,7 +1217,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1233,7 +1233,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1249,7 +1249,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Float) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1265,7 +1265,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Double) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1281,7 +1281,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1297,7 +1297,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1313,7 +1313,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1329,7 +1329,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1345,7 +1345,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1361,7 +1361,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1377,7 +1377,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1393,7 +1393,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1409,7 +1409,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1425,7 +1425,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1441,7 +1441,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1457,7 +1457,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1489,7 +1489,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1505,7 +1505,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1521,7 +1521,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1537,7 +1537,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1553,7 +1553,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1569,7 +1569,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1585,7 +1585,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1601,7 +1601,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1617,7 +1617,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1633,7 +1633,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1649,7 +1649,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1665,7 +1665,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1681,7 +1681,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1697,7 +1697,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1713,7 +1713,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1729,7 +1729,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1745,7 +1745,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1761,7 +1761,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1777,7 +1777,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1793,7 +1793,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1809,7 +1809,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1825,7 +1825,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1841,7 +1841,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1857,7 +1857,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1873,7 +1873,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1889,7 +1889,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1905,7 +1905,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Float) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1921,7 +1921,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Double) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1937,7 +1937,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1953,7 +1953,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1969,7 +1969,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1985,7 +1985,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2001,7 +2001,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2017,7 +2017,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2033,7 +2033,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2051,7 +2051,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2067,7 +2067,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2083,7 +2083,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2099,7 +2099,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2115,7 +2115,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2131,7 +2131,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2147,7 +2147,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2163,7 +2163,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2179,7 +2179,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2197,7 +2197,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2213,7 +2213,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2229,7 +2229,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2249,7 +2249,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2265,7 +2265,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2283,7 +2283,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2307,7 +2307,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2318,4 +2318,3 @@ public Map> getWriteAttributeMap() { return writeAttributeMap; } } - From 837dfffe9a345bba39c186722272a6c0b9e447ec Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Mon, 31 Jan 2022 21:00:30 +0000 Subject: [PATCH 10/14] Restyled by google-java-format --- .../chip/devicecontroller/ChipClusters.java | 23133 ++++++++-------- .../chip/devicecontroller/ChipStructs.java | 4075 ++- .../devicecontroller/ClusterInfoMapping.java | 16452 ++++++----- .../devicecontroller/ClusterReadMapping.java | 16098 +++++------ .../devicecontroller/ClusterWriteMapping.java | 4746 ++-- 5 files changed, 33661 insertions(+), 30843 deletions(-) diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index 84244edbcb62c1..5d633d4dab05af 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -21,7 +21,6 @@ import androidx.annotation.Nullable; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; import java.util.Optional; @@ -29,54 +28,69 @@ public class ChipClusters { public interface DefaultClusterCallback { void onSuccess(); + void onError(Exception error); } public interface CharStringAttributeCallback { /** Indicates a successful read for a CHAR_STRING attribute. */ void onSuccess(String value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface OctetStringAttributeCallback { /** Indicates a successful read for an OCTET_STRING attribute. */ void onSuccess(byte[] value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface IntegerAttributeCallback { void onSuccess(int value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface LongAttributeCallback { void onSuccess(long value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface BooleanAttributeCallback { void onSuccess(boolean value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface FloatAttributeCallback { void onSuccess(float value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface DoubleAttributeCallback { void onSuccess(double value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } - public static abstract class BaseChipCluster { + public abstract static class BaseChipCluster { protected long chipClusterPtr; public BaseChipCluster(long devicePtr, int endpointId) { @@ -108,115 +122,129 @@ public AccessControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AclAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ExtensionAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AclAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ExtensionAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAclAttribute( - AclAttributeCallback callback - ) { + public void readAclAttribute(AclAttributeCallback callback) { readAclAttribute(chipClusterPtr, callback); } - public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeAclAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeAclAttribute(chipClusterPtr, callback, value, null); } - public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeAclAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeAclAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeAclAttribute( - AclAttributeCallback callback - , - int minInterval, int maxInterval) { + AclAttributeCallback callback, int minInterval, int maxInterval) { subscribeAclAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readExtensionAttribute( - ExtensionAttributeCallback callback - ) { + public void readExtensionAttribute(ExtensionAttributeCallback callback) { readExtensionAttribute(chipClusterPtr, callback); } - public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeExtensionAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeExtensionAttribute(chipClusterPtr, callback, value, null); } - public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeExtensionAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeExtensionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeExtensionAttribute( - ExtensionAttributeCallback callback - , - int minInterval, int maxInterval) { + ExtensionAttributeCallback callback, int minInterval, int maxInterval) { subscribeExtensionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAclAttribute(long chipClusterPtr, - AclAttributeCallback callback - ); - - private native void writeAclAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeAclAttribute(long chipClusterPtr, - AclAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readExtensionAttribute(long chipClusterPtr, - ExtensionAttributeCallback callback - ); - - private native void writeExtensionAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeExtensionAttribute(long chipClusterPtr, - ExtensionAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readAclAttribute(long chipClusterPtr, AclAttributeCallback callback); + + private native void writeAclAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeAclAttribute( + long chipClusterPtr, AclAttributeCallback callback, int minInterval, int maxInterval); + + private native void readExtensionAttribute( + long chipClusterPtr, ExtensionAttributeCallback callback); + + private native void writeExtensionAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeExtensionAttribute( + long chipClusterPtr, ExtensionAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class AccountLoginCluster extends BaseChipCluster { @@ -229,85 +257,90 @@ public AccountLoginCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - - public void getSetupPINRequest(GetSetupPINResponseCallback callback - , String tempAccountIdentifier - , int timedInvokeTimeoutMs) { + public void getSetupPINRequest( + GetSetupPINResponseCallback callback, + String tempAccountIdentifier, + int timedInvokeTimeoutMs) { getSetupPINRequest(chipClusterPtr, callback, tempAccountIdentifier, timedInvokeTimeoutMs); } - - public void loginRequest(DefaultClusterCallback callback - , String tempAccountIdentifier, String setupPIN - , int timedInvokeTimeoutMs) { + public void loginRequest( + DefaultClusterCallback callback, + String tempAccountIdentifier, + String setupPIN, + int timedInvokeTimeoutMs) { loginRequest(chipClusterPtr, callback, tempAccountIdentifier, setupPIN, timedInvokeTimeoutMs); } + public void logoutRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - public void logoutRequest(DefaultClusterCallback callback - - , int timedInvokeTimeoutMs) { logoutRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void getSetupPINRequest(long chipClusterPtr, GetSetupPINResponseCallback Callback - , String tempAccountIdentifier - , @Nullable Integer timedInvokeTimeoutMs); - private native void loginRequest(long chipClusterPtr, DefaultClusterCallback Callback - , String tempAccountIdentifier, String setupPIN - , @Nullable Integer timedInvokeTimeoutMs); - private native void logoutRequest(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void getSetupPINRequest( + long chipClusterPtr, + GetSetupPINResponseCallback Callback, + String tempAccountIdentifier, + @Nullable Integer timedInvokeTimeoutMs); + + private native void loginRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + String tempAccountIdentifier, + String setupPIN, + @Nullable Integer timedInvokeTimeoutMs); + + private native void logoutRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + public interface GetSetupPINResponseCallback { void onSuccess(String setupPIN); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 AdministratorCommissioningCluster extends BaseChipCluster { @@ -320,141 +353,156 @@ public AdministratorCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); + public void openBasicCommissioningWindow( + DefaultClusterCallback callback, Integer commissioningTimeout, int timedInvokeTimeoutMs) { + openBasicCommissioningWindow( + chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs); + } + + public void openCommissioningWindow( + DefaultClusterCallback callback, + Integer commissioningTimeout, + byte[] PAKEVerifier, + Integer discriminator, + Long iterations, + byte[] salt, + Integer passcodeID, + int timedInvokeTimeoutMs) { + openCommissioningWindow( + chipClusterPtr, + callback, + commissioningTimeout, + PAKEVerifier, + discriminator, + iterations, + salt, + passcodeID, + timedInvokeTimeoutMs); + } + + public void revokeCommissioning(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - public void openBasicCommissioningWindow(DefaultClusterCallback callback - , Integer commissioningTimeout - , int timedInvokeTimeoutMs) { - openBasicCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs); + revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void openBasicCommissioningWindow( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer commissioningTimeout, + @Nullable Integer timedInvokeTimeoutMs); - public void openCommissioningWindow(DefaultClusterCallback callback - , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID - , int timedInvokeTimeoutMs) { - openCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, PAKEVerifier, discriminator, iterations, salt, passcodeID, timedInvokeTimeoutMs); - } + private native void openCommissioningWindow( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer commissioningTimeout, + byte[] PAKEVerifier, + Integer discriminator, + Long iterations, + byte[] salt, + Integer passcodeID, + @Nullable Integer timedInvokeTimeoutMs); + private native void revokeCommissioning( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public void revokeCommissioning(DefaultClusterCallback callback + public interface AdminFabricIndexAttributeCallback { + void onSuccess(Integer value); - , int timedInvokeTimeoutMs) { - revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void openBasicCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback - , Integer commissioningTimeout - , @Nullable Integer timedInvokeTimeoutMs); - private native void openCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback - , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void revokeCommissioning(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AdminFabricIndexAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readWindowStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readWindowStatusAttribute(IntegerAttributeCallback callback) { readWindowStatusAttribute(chipClusterPtr, callback); } + public void subscribeWindowStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWindowStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAdminFabricIndexAttribute( - AdminFabricIndexAttributeCallback callback - ) { + public void readAdminFabricIndexAttribute(AdminFabricIndexAttributeCallback callback) { readAdminFabricIndexAttribute(chipClusterPtr, callback); } + public void subscribeAdminFabricIndexAttribute( - AdminFabricIndexAttributeCallback callback - , - int minInterval, int maxInterval) { + AdminFabricIndexAttributeCallback callback, int minInterval, int maxInterval) { subscribeAdminFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAdminVendorIdAttribute( - IntegerAttributeCallback callback - ) { + public void readAdminVendorIdAttribute(IntegerAttributeCallback callback) { readAdminVendorIdAttribute(chipClusterPtr, callback); } + public void subscribeAdminVendorIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAdminVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readWindowStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeWindowStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAdminFabricIndexAttribute(long chipClusterPtr, - AdminFabricIndexAttributeCallback callback - ); - private native void subscribeAdminFabricIndexAttribute(long chipClusterPtr, - AdminFabricIndexAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readAdminVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAdminVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readWindowStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeWindowStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAdminFabricIndexAttribute( + long chipClusterPtr, AdminFabricIndexAttributeCallback callback); + + private native void subscribeAdminFabricIndexAttribute( + long chipClusterPtr, + AdminFabricIndexAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readAdminVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAdminVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ApplicationBasicCluster extends BaseChipCluster { @@ -467,187 +515,171 @@ public ApplicationBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AllowedVendorListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AllowedVendorListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readVendorNameAttribute( - CharStringAttributeCallback callback - ) { + public void readVendorNameAttribute(CharStringAttributeCallback callback) { readVendorNameAttribute(chipClusterPtr, callback); } + public void subscribeVendorNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIdAttribute( - IntegerAttributeCallback callback - ) { + public void readVendorIdAttribute(IntegerAttributeCallback callback) { readVendorIdAttribute(chipClusterPtr, callback); } + public void subscribeVendorIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationNameAttribute( - CharStringAttributeCallback callback - ) { + public void readApplicationNameAttribute(CharStringAttributeCallback callback) { readApplicationNameAttribute(chipClusterPtr, callback); } + public void subscribeApplicationNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductIdAttribute( - IntegerAttributeCallback callback - ) { + public void readProductIdAttribute(IntegerAttributeCallback callback) { readProductIdAttribute(chipClusterPtr, callback); } + public void subscribeProductIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readApplicationStatusAttribute(IntegerAttributeCallback callback) { readApplicationStatusAttribute(chipClusterPtr, callback); } + public void subscribeApplicationStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationVersionAttribute( - CharStringAttributeCallback callback - ) { + public void readApplicationVersionAttribute(CharStringAttributeCallback callback) { readApplicationVersionAttribute(chipClusterPtr, callback); } + public void subscribeApplicationVersionAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAllowedVendorListAttribute( - AllowedVendorListAttributeCallback callback - ) { + public void readAllowedVendorListAttribute(AllowedVendorListAttributeCallback callback) { readAllowedVendorListAttribute(chipClusterPtr, callback); } + public void subscribeAllowedVendorListAttribute( - AllowedVendorListAttributeCallback callback - , - int minInterval, int maxInterval) { + AllowedVendorListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAllowedVendorListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readApplicationNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeApplicationNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeProductIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readApplicationStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeApplicationStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readApplicationVersionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeApplicationVersionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAllowedVendorListAttribute(long chipClusterPtr, - AllowedVendorListAttributeCallback callback - ); - private native void subscribeAllowedVendorListAttribute(long chipClusterPtr, - AllowedVendorListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readVendorNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeVendorNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readApplicationNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeApplicationNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeProductIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readApplicationStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeApplicationStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readApplicationVersionAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeApplicationVersionAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readAllowedVendorListAttribute( + long chipClusterPtr, AllowedVendorListAttributeCallback callback); + + private native void subscribeAllowedVendorListAttribute( + long chipClusterPtr, + AllowedVendorListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ApplicationLauncherCluster extends BaseChipCluster { @@ -660,121 +692,139 @@ public ApplicationLauncherCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void hideAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void hideAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { hideAppRequest(chipClusterPtr, callback, application, null); } - public void hideAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , int timedInvokeTimeoutMs) { + public void hideAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + int timedInvokeTimeoutMs) { hideAppRequest(chipClusterPtr, callback, application, timedInvokeTimeoutMs); } - public void launchAppRequest(LauncherResponseCallback callback - , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void launchAppRequest( + LauncherResponseCallback callback, + String data, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { launchAppRequest(chipClusterPtr, callback, data, application, null); } - public void launchAppRequest(LauncherResponseCallback callback - , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , int timedInvokeTimeoutMs) { + public void launchAppRequest( + LauncherResponseCallback callback, + String data, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + int timedInvokeTimeoutMs) { launchAppRequest(chipClusterPtr, callback, data, application, timedInvokeTimeoutMs); } - public void stopAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void stopAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { stopAppRequest(chipClusterPtr, callback, application, null); } - public void stopAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , int timedInvokeTimeoutMs) { + public void stopAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + int timedInvokeTimeoutMs) { stopAppRequest(chipClusterPtr, callback, application, timedInvokeTimeoutMs); } - private native void hideAppRequest(long chipClusterPtr, LauncherResponseCallback Callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , @Nullable Integer timedInvokeTimeoutMs); - private native void launchAppRequest(long chipClusterPtr, LauncherResponseCallback Callback - , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopAppRequest(long chipClusterPtr, LauncherResponseCallback Callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , @Nullable Integer timedInvokeTimeoutMs); + + private native void hideAppRequest( + long chipClusterPtr, + LauncherResponseCallback Callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + @Nullable Integer timedInvokeTimeoutMs); + + private native void launchAppRequest( + long chipClusterPtr, + LauncherResponseCallback Callback, + String data, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopAppRequest( + long chipClusterPtr, + LauncherResponseCallback Callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + @Nullable Integer timedInvokeTimeoutMs); + public interface LauncherResponseCallback { void onSuccess(Integer status, String data); void onError(Exception error); } + public interface ApplicationLauncherListAttributeCallback { + void onSuccess(List valueList); - public interface ApplicationLauncherListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } public void readApplicationLauncherListAttribute( - ApplicationLauncherListAttributeCallback callback - ) { + ApplicationLauncherListAttributeCallback callback) { readApplicationLauncherListAttribute(chipClusterPtr, callback); } + public void subscribeApplicationLauncherListAttribute( - ApplicationLauncherListAttributeCallback callback - , - int minInterval, int maxInterval) { + ApplicationLauncherListAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationLauncherListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readApplicationLauncherListAttribute(long chipClusterPtr, - ApplicationLauncherListAttributeCallback callback - ); - private native void subscribeApplicationLauncherListAttribute(long chipClusterPtr, - ApplicationLauncherListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readApplicationLauncherListAttribute( + long chipClusterPtr, ApplicationLauncherListAttributeCallback callback); + + private native void subscribeApplicationLauncherListAttribute( + long chipClusterPtr, + ApplicationLauncherListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class AudioOutputCluster extends BaseChipCluster { @@ -787,120 +837,118 @@ public AudioOutputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void renameOutputRequest(DefaultClusterCallback callback - , Integer index, String name) { + public void renameOutputRequest(DefaultClusterCallback callback, Integer index, String name) { renameOutputRequest(chipClusterPtr, callback, index, name, null); } - public void renameOutputRequest(DefaultClusterCallback callback - , Integer index, String name - , int timedInvokeTimeoutMs) { + public void renameOutputRequest( + DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) { renameOutputRequest(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); } - public void selectOutputRequest(DefaultClusterCallback callback - , Integer index) { + public void selectOutputRequest(DefaultClusterCallback callback, Integer index) { selectOutputRequest(chipClusterPtr, callback, index, null); } - public void selectOutputRequest(DefaultClusterCallback callback - , Integer index - , int timedInvokeTimeoutMs) { + public void selectOutputRequest( + DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) { selectOutputRequest(chipClusterPtr, callback, index, timedInvokeTimeoutMs); } - private native void renameOutputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index, String name - , @Nullable Integer timedInvokeTimeoutMs); - private native void selectOutputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index - , @Nullable Integer timedInvokeTimeoutMs); - - public interface AudioOutputListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readAudioOutputListAttribute( - AudioOutputListAttributeCallback callback - ) { + private native void renameOutputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + String name, + @Nullable Integer timedInvokeTimeoutMs); + + private native void selectOutputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AudioOutputListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readAudioOutputListAttribute(AudioOutputListAttributeCallback callback) { readAudioOutputListAttribute(chipClusterPtr, callback); } + public void subscribeAudioOutputListAttribute( - AudioOutputListAttributeCallback callback - , - int minInterval, int maxInterval) { + AudioOutputListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAudioOutputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentAudioOutputAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentAudioOutputAttribute(IntegerAttributeCallback callback) { readCurrentAudioOutputAttribute(chipClusterPtr, callback); } + public void subscribeCurrentAudioOutputAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentAudioOutputAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAudioOutputListAttribute(long chipClusterPtr, - AudioOutputListAttributeCallback callback - ); - private native void subscribeAudioOutputListAttribute(long chipClusterPtr, - AudioOutputListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentAudioOutputAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentAudioOutputAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readAudioOutputListAttribute( + long chipClusterPtr, AudioOutputListAttributeCallback callback); + + private native void subscribeAudioOutputListAttribute( + long chipClusterPtr, + AudioOutputListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentAudioOutputAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentAudioOutputAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BarrierControlCluster extends BaseChipCluster { @@ -913,153 +961,135 @@ public BarrierControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void barrierControlGoToPercent(DefaultClusterCallback callback - , Integer percentOpen) { + public void barrierControlGoToPercent(DefaultClusterCallback callback, Integer percentOpen) { barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, null); } - public void barrierControlGoToPercent(DefaultClusterCallback callback - , Integer percentOpen - , int timedInvokeTimeoutMs) { + public void barrierControlGoToPercent( + DefaultClusterCallback callback, Integer percentOpen, int timedInvokeTimeoutMs) { barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, timedInvokeTimeoutMs); } - public void barrierControlStop(DefaultClusterCallback callback - ) { + public void barrierControlStop(DefaultClusterCallback callback) { barrierControlStop(chipClusterPtr, callback, null); } - public void barrierControlStop(DefaultClusterCallback callback + public void barrierControlStop(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { barrierControlStop(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void barrierControlGoToPercent(long chipClusterPtr, DefaultClusterCallback Callback - , Integer percentOpen - , @Nullable Integer timedInvokeTimeoutMs); - private native void barrierControlStop(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void barrierControlGoToPercent( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer percentOpen, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void barrierControlStop( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readBarrierMovingStateAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readBarrierMovingStateAttribute(IntegerAttributeCallback callback) { readBarrierMovingStateAttribute(chipClusterPtr, callback); } + public void subscribeBarrierMovingStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierMovingStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierSafetyStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readBarrierSafetyStatusAttribute(IntegerAttributeCallback callback) { readBarrierSafetyStatusAttribute(chipClusterPtr, callback); } + public void subscribeBarrierSafetyStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierCapabilitiesAttribute( - IntegerAttributeCallback callback - ) { + public void readBarrierCapabilitiesAttribute(IntegerAttributeCallback callback) { readBarrierCapabilitiesAttribute(chipClusterPtr, callback); } + public void subscribeBarrierCapabilitiesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierPositionAttribute( - IntegerAttributeCallback callback - ) { + public void readBarrierPositionAttribute(IntegerAttributeCallback callback) { readBarrierPositionAttribute(chipClusterPtr, callback); } + public void subscribeBarrierPositionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBarrierMovingStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierMovingStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBarrierSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBarrierCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBarrierPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readBarrierMovingStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierMovingStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBarrierSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBarrierCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBarrierPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BasicCluster extends BaseChipCluster { @@ -1072,442 +1102,420 @@ public BasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface VendorIDAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface VendorIDAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readInteractionModelVersionAttribute( - IntegerAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readInteractionModelVersionAttribute(IntegerAttributeCallback callback) { readInteractionModelVersionAttribute(chipClusterPtr, callback); } + public void subscribeInteractionModelVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInteractionModelVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorNameAttribute( - CharStringAttributeCallback callback - ) { + public void readVendorNameAttribute(CharStringAttributeCallback callback) { readVendorNameAttribute(chipClusterPtr, callback); } + public void subscribeVendorNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIDAttribute( - VendorIDAttributeCallback callback - ) { + public void readVendorIDAttribute(VendorIDAttributeCallback callback) { readVendorIDAttribute(chipClusterPtr, callback); } + public void subscribeVendorIDAttribute( - VendorIDAttributeCallback callback - , - int minInterval, int maxInterval) { + VendorIDAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductNameAttribute( - CharStringAttributeCallback callback - ) { + public void readProductNameAttribute(CharStringAttributeCallback callback) { readProductNameAttribute(chipClusterPtr, callback); } + public void subscribeProductNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductIDAttribute( - IntegerAttributeCallback callback - ) { + public void readProductIDAttribute(IntegerAttributeCallback callback) { readProductIDAttribute(chipClusterPtr, callback); } + public void subscribeProductIDAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNodeLabelAttribute( - CharStringAttributeCallback callback - ) { + public void readNodeLabelAttribute(CharStringAttributeCallback callback) { readNodeLabelAttribute(chipClusterPtr, callback); } + public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value) { writeNodeLabelAttribute(chipClusterPtr, callback, value, null); } - public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeNodeLabelAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeNodeLabelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNodeLabelAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNodeLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocationAttribute( - CharStringAttributeCallback callback - ) { + public void readLocationAttribute(CharStringAttributeCallback callback) { readLocationAttribute(chipClusterPtr, callback); } + public void writeLocationAttribute(DefaultClusterCallback callback, String value) { writeLocationAttribute(chipClusterPtr, callback, value, null); } - public void writeLocationAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLocationAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLocationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLocationAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readHardwareVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readHardwareVersionAttribute(IntegerAttributeCallback callback) { readHardwareVersionAttribute(chipClusterPtr, callback); } + public void subscribeHardwareVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeHardwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readHardwareVersionStringAttribute( - CharStringAttributeCallback callback - ) { + public void readHardwareVersionStringAttribute(CharStringAttributeCallback callback) { readHardwareVersionStringAttribute(chipClusterPtr, callback); } + public void subscribeHardwareVersionStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeHardwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoftwareVersionAttribute( - LongAttributeCallback callback - ) { + public void readSoftwareVersionAttribute(LongAttributeCallback callback) { readSoftwareVersionAttribute(chipClusterPtr, callback); } + public void subscribeSoftwareVersionAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeSoftwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoftwareVersionStringAttribute( - CharStringAttributeCallback callback - ) { + public void readSoftwareVersionStringAttribute(CharStringAttributeCallback callback) { readSoftwareVersionStringAttribute(chipClusterPtr, callback); } + public void subscribeSoftwareVersionStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeSoftwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readManufacturingDateAttribute( - CharStringAttributeCallback callback - ) { + public void readManufacturingDateAttribute(CharStringAttributeCallback callback) { readManufacturingDateAttribute(chipClusterPtr, callback); } + public void subscribeManufacturingDateAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeManufacturingDateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartNumberAttribute( - CharStringAttributeCallback callback - ) { + public void readPartNumberAttribute(CharStringAttributeCallback callback) { readPartNumberAttribute(chipClusterPtr, callback); } + public void subscribePartNumberAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribePartNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductURLAttribute( - CharStringAttributeCallback callback - ) { + public void readProductURLAttribute(CharStringAttributeCallback callback) { readProductURLAttribute(chipClusterPtr, callback); } + public void subscribeProductURLAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductURLAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductLabelAttribute( - CharStringAttributeCallback callback - ) { + public void readProductLabelAttribute(CharStringAttributeCallback callback) { readProductLabelAttribute(chipClusterPtr, callback); } + public void subscribeProductLabelAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSerialNumberAttribute( - CharStringAttributeCallback callback - ) { + public void readSerialNumberAttribute(CharStringAttributeCallback callback) { readSerialNumberAttribute(chipClusterPtr, callback); } + public void subscribeSerialNumberAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeSerialNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocalConfigDisabledAttribute( - BooleanAttributeCallback callback - ) { + public void readLocalConfigDisabledAttribute(BooleanAttributeCallback callback) { readLocalConfigDisabledAttribute(chipClusterPtr, callback); } + public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value) { writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, null); } - public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeLocalConfigDisabledAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLocalConfigDisabledAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocalConfigDisabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readReachableAttribute( - BooleanAttributeCallback callback - ) { + public void readReachableAttribute(BooleanAttributeCallback callback) { readReachableAttribute(chipClusterPtr, callback); } + public void subscribeReachableAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeReachableAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUniqueIDAttribute( - CharStringAttributeCallback callback - ) { + public void readUniqueIDAttribute(CharStringAttributeCallback callback) { readUniqueIDAttribute(chipClusterPtr, callback); } + public void subscribeUniqueIDAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeUniqueIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readInteractionModelVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInteractionModelVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorIDAttribute(long chipClusterPtr, - VendorIDAttributeCallback callback - ); - private native void subscribeVendorIDAttribute(long chipClusterPtr, - VendorIDAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readProductNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeProductNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductIDAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeProductIDAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNodeLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeNodeLabelAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNodeLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLocationAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeLocationAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLocationAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readHardwareVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeHardwareVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readHardwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeHardwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSoftwareVersionAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeSoftwareVersionAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSoftwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeSoftwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readManufacturingDateAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeManufacturingDateAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPartNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribePartNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductURLAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeProductURLAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeProductLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSerialNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeSerialNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLocalConfigDisabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeLocalConfigDisabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLocalConfigDisabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readReachableAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeReachableAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUniqueIDAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeUniqueIDAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readInteractionModelVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInteractionModelVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readVendorNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeVendorNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readVendorIDAttribute( + long chipClusterPtr, VendorIDAttributeCallback callback); + + private native void subscribeVendorIDAttribute( + long chipClusterPtr, VendorIDAttributeCallback callback, int minInterval, int maxInterval); + + private native void readProductNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeProductNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductIDAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeProductIDAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNodeLabelAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeNodeLabelAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNodeLabelAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLocationAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeLocationAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLocationAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readHardwareVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeHardwareVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readHardwareVersionStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeHardwareVersionStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSoftwareVersionAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeSoftwareVersionAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSoftwareVersionStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeSoftwareVersionStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readManufacturingDateAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeManufacturingDateAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPartNumberAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribePartNumberAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductURLAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeProductURLAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductLabelAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeProductLabelAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSerialNumberAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeSerialNumberAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLocalConfigDisabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeLocalConfigDisabledAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLocalConfigDisabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readReachableAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeReachableAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUniqueIDAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeUniqueIDAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BinaryInputBasicCluster extends BaseChipCluster { @@ -1520,207 +1528,230 @@ public BinaryInputBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readOutOfServiceAttribute( - BooleanAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readOutOfServiceAttribute(BooleanAttributeCallback callback) { readOutOfServiceAttribute(chipClusterPtr, callback); } + public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value) { writeOutOfServiceAttribute(chipClusterPtr, callback, value, null); } - public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeOutOfServiceAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeOutOfServiceAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOutOfServiceAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeOutOfServiceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPresentValueAttribute( - BooleanAttributeCallback callback - ) { + public void readPresentValueAttribute(BooleanAttributeCallback callback) { readPresentValueAttribute(chipClusterPtr, callback); } + public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value) { writePresentValueAttribute(chipClusterPtr, callback, value, null); } - public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writePresentValueAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writePresentValueAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribePresentValueAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribePresentValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStatusFlagsAttribute( - IntegerAttributeCallback callback - ) { + public void readStatusFlagsAttribute(IntegerAttributeCallback callback) { readStatusFlagsAttribute(chipClusterPtr, callback); } + public void subscribeStatusFlagsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStatusFlagsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOutOfServiceAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeOutOfServiceAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOutOfServiceAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPresentValueAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writePresentValueAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribePresentValueAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStatusFlagsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStatusFlagsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + private native void readOutOfServiceAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); - public static class BindingCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 30L; + private native void writeOutOfServiceAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); - public BindingCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void subscribeOutOfServiceAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPresentValueAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writePresentValueAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribePresentValueAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStatusFlagsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStatusFlagsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class BindingCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 30L; + + public BindingCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } @Override public native long initWithDevice(long devicePtr, int endpointId); - public void bind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId) { + public void bind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId) { bind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, null); } - public void bind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , int timedInvokeTimeoutMs) { + public void bind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + int timedInvokeTimeoutMs) { bind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); } - public void unbind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId) { + public void unbind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId) { unbind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, null); } - public void unbind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , int timedInvokeTimeoutMs) { - unbind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); + public void unbind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + int timedInvokeTimeoutMs) { + unbind( + chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); } - private native void bind(long chipClusterPtr, DefaultClusterCallback Callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , @Nullable Integer timedInvokeTimeoutMs); - private native void unbind(long chipClusterPtr, DefaultClusterCallback Callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void bind( + long chipClusterPtr, + DefaultClusterCallback Callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void unbind( + long chipClusterPtr, + DefaultClusterCallback Callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 BooleanStateCluster extends BaseChipCluster { @@ -1733,68 +1764,61 @@ public BooleanStateCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readStateValueAttribute( - BooleanAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readStateValueAttribute(BooleanAttributeCallback callback) { readStateValueAttribute(chipClusterPtr, callback); } + public void subscribeStateValueAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeStateValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readStateValueAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeStateValueAttribute(long chipClusterPtr, - BooleanAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readStateValueAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeStateValueAttribute( + long chipClusterPtr, BooleanAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BridgedActionsCluster extends BaseChipCluster { @@ -1807,284 +1831,375 @@ public BridgedActionsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void disableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void disableAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { disableAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void disableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void disableAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { disableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void disableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void disableActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void disableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void disableActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + disableActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void enableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void enableAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { enableAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void enableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void enableAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { enableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void enableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void enableActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void enableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void enableActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + enableActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void instantAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void instantAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { instantAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void instantAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void instantAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { instantAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void instantActionWithTransition(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Integer transitionTime) { - instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, null); + public void instantActionWithTransition( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Integer transitionTime) { + instantActionWithTransition( + chipClusterPtr, callback, actionID, invokeID, transitionTime, null); } - public void instantActionWithTransition(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Integer transitionTime - , int timedInvokeTimeoutMs) { - instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs); + public void instantActionWithTransition( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Integer transitionTime, + int timedInvokeTimeoutMs) { + instantActionWithTransition( + chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs); } - public void pauseAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void pauseAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { pauseAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void pauseAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void pauseAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { pauseAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void pauseActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void pauseActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void pauseActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void pauseActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + pauseActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void resumeAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void resumeAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { resumeAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void resumeAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void resumeAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { resumeAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void startAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void startAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { startAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void startAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void startAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { startAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void startActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void startActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void startActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void startActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + startActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void stopAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void stopAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { stopAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void stopAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void stopAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { stopAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - private native void disableAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void disableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void enableAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void enableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void instantAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void instantActionWithTransition(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void pauseAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void pauseActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void resumeAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void startAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void startActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - - public interface ActionListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface EndpointListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readActionListAttribute( - ActionListAttributeCallback callback - ) { + private native void disableAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void disableActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enableAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enableActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void instantAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void instantActionWithTransition( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void pauseAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void pauseActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void resumeAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void startAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void startActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + public interface ActionListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface EndpointListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readActionListAttribute(ActionListAttributeCallback callback) { readActionListAttribute(chipClusterPtr, callback); } + public void subscribeActionListAttribute( - ActionListAttributeCallback callback - , - int minInterval, int maxInterval) { + ActionListAttributeCallback callback, int minInterval, int maxInterval) { subscribeActionListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEndpointListAttribute( - EndpointListAttributeCallback callback - ) { + public void readEndpointListAttribute(EndpointListAttributeCallback callback) { readEndpointListAttribute(chipClusterPtr, callback); } + public void subscribeEndpointListAttribute( - EndpointListAttributeCallback callback - , - int minInterval, int maxInterval) { + EndpointListAttributeCallback callback, int minInterval, int maxInterval) { subscribeEndpointListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSetupUrlAttribute( - CharStringAttributeCallback callback - ) { + public void readSetupUrlAttribute(CharStringAttributeCallback callback) { readSetupUrlAttribute(chipClusterPtr, callback); } + public void subscribeSetupUrlAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeSetupUrlAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readActionListAttribute(long chipClusterPtr, - ActionListAttributeCallback callback - ); - private native void subscribeActionListAttribute(long chipClusterPtr, - ActionListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readEndpointListAttribute(long chipClusterPtr, - EndpointListAttributeCallback callback - ); - private native void subscribeEndpointListAttribute(long chipClusterPtr, - EndpointListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readSetupUrlAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeSetupUrlAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readActionListAttribute( + long chipClusterPtr, ActionListAttributeCallback callback); + + private native void subscribeActionListAttribute( + long chipClusterPtr, + ActionListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEndpointListAttribute( + long chipClusterPtr, EndpointListAttributeCallback callback); + + private native void subscribeEndpointListAttribute( + long chipClusterPtr, + EndpointListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSetupUrlAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeSetupUrlAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BridgedDeviceBasicCluster extends BaseChipCluster { @@ -2097,49 +2212,46 @@ public BridgedDeviceBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - private native void readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ChannelCluster extends BaseChipCluster { @@ -2152,121 +2264,129 @@ public ChannelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void changeChannelByNumberRequest(DefaultClusterCallback callback - , Integer majorNumber, Integer minorNumber) { + public void changeChannelByNumberRequest( + DefaultClusterCallback callback, Integer majorNumber, Integer minorNumber) { changeChannelByNumberRequest(chipClusterPtr, callback, majorNumber, minorNumber, null); } - public void changeChannelByNumberRequest(DefaultClusterCallback callback - , Integer majorNumber, Integer minorNumber - , int timedInvokeTimeoutMs) { - changeChannelByNumberRequest(chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs); + public void changeChannelByNumberRequest( + DefaultClusterCallback callback, + Integer majorNumber, + Integer minorNumber, + int timedInvokeTimeoutMs) { + changeChannelByNumberRequest( + chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs); } - public void changeChannelRequest(ChangeChannelResponseCallback callback - , String match) { + public void changeChannelRequest(ChangeChannelResponseCallback callback, String match) { changeChannelRequest(chipClusterPtr, callback, match, null); } - public void changeChannelRequest(ChangeChannelResponseCallback callback - , String match - , int timedInvokeTimeoutMs) { + public void changeChannelRequest( + ChangeChannelResponseCallback callback, String match, int timedInvokeTimeoutMs) { changeChannelRequest(chipClusterPtr, callback, match, timedInvokeTimeoutMs); } - public void skipChannelRequest(DefaultClusterCallback callback - , Integer count) { + public void skipChannelRequest(DefaultClusterCallback callback, Integer count) { skipChannelRequest(chipClusterPtr, callback, count, null); } - public void skipChannelRequest(DefaultClusterCallback callback - , Integer count - , int timedInvokeTimeoutMs) { + public void skipChannelRequest( + DefaultClusterCallback callback, Integer count, int timedInvokeTimeoutMs) { skipChannelRequest(chipClusterPtr, callback, count, timedInvokeTimeoutMs); } - private native void changeChannelByNumberRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer majorNumber, Integer minorNumber - , @Nullable Integer timedInvokeTimeoutMs); - private native void changeChannelRequest(long chipClusterPtr, ChangeChannelResponseCallback Callback - , String match - , @Nullable Integer timedInvokeTimeoutMs); - private native void skipChannelRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer count - , @Nullable Integer timedInvokeTimeoutMs); + + private native void changeChannelByNumberRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer majorNumber, + Integer minorNumber, + @Nullable Integer timedInvokeTimeoutMs); + + private native void changeChannelRequest( + long chipClusterPtr, + ChangeChannelResponseCallback Callback, + String match, + @Nullable Integer timedInvokeTimeoutMs); + + private native void skipChannelRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer count, + @Nullable Integer timedInvokeTimeoutMs); + public interface ChangeChannelResponseCallback { void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType); void onError(Exception error); } + public interface ChannelListAttributeCallback { + void onSuccess(List valueList); - public interface ChannelListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readChannelListAttribute( - ChannelListAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readChannelListAttribute(ChannelListAttributeCallback callback) { readChannelListAttribute(chipClusterPtr, callback); } + public void subscribeChannelListAttribute( - ChannelListAttributeCallback callback - , - int minInterval, int maxInterval) { + ChannelListAttributeCallback callback, int minInterval, int maxInterval) { subscribeChannelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readChannelListAttribute(long chipClusterPtr, - ChannelListAttributeCallback callback - ); - private native void subscribeChannelListAttribute(long chipClusterPtr, - ChannelListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readChannelListAttribute( + long chipClusterPtr, ChannelListAttributeCallback callback); + + private native void subscribeChannelListAttribute( + long chipClusterPtr, + ChannelListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ColorControlCluster extends BaseChipCluster { @@ -2279,1561 +2399,2031 @@ public ColorControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void colorLoopSet(DefaultClusterCallback callback - , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride) { - colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, null); - } - - public void colorLoopSet(DefaultClusterCallback callback - , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedMoveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + public void colorLoopSet( + DefaultClusterCallback callback, + Integer updateFlags, + Integer action, + Integer direction, + Integer time, + Integer startHue, + Integer optionsMask, + Integer optionsOverride) { + colorLoopSet( + chipClusterPtr, + callback, + updateFlags, + action, + direction, + time, + startHue, + optionsMask, + optionsOverride, + null); + } + + public void colorLoopSet( + DefaultClusterCallback callback, + Integer updateFlags, + Integer action, + Integer direction, + Integer time, + Integer startHue, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + colorLoopSet( + chipClusterPtr, + callback, + updateFlags, + action, + direction, + time, + startHue, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedMoveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride) { enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void enhancedMoveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedMoveToHue(DefaultClusterCallback callback - , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, null); - } - - public void enhancedMoveToHue(DefaultClusterCallback callback - , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback - , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, null); - } - - public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback - , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedStepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); - } - - public void enhancedStepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveColor(DefaultClusterCallback callback - , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride) { + public void enhancedMoveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedMoveHue( + chipClusterPtr, + callback, + moveMode, + rate, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedMoveToHue( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + enhancedMoveToHue( + chipClusterPtr, + callback, + enhancedHue, + direction, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void enhancedMoveToHue( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedMoveToHue( + chipClusterPtr, + callback, + enhancedHue, + direction, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedMoveToHueAndSaturation( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + enhancedMoveToHueAndSaturation( + chipClusterPtr, + callback, + enhancedHue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void enhancedMoveToHueAndSaturation( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedMoveToHueAndSaturation( + chipClusterPtr, + callback, + enhancedHue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedStepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + enhancedStepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void enhancedStepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedStepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveColor( + DefaultClusterCallback callback, + Integer rateX, + Integer rateY, + Integer optionsMask, + Integer optionsOverride) { moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, null); } - public void moveColor(DefaultClusterCallback callback - , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveColorTemperature(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride) { - moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, null); - } - - public void moveColorTemperature(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + public void moveColor( + DefaultClusterCallback callback, + Integer rateX, + Integer rateY, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveColor( + chipClusterPtr, + callback, + rateX, + rateY, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveColorTemperature( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride) { + moveColorTemperature( + chipClusterPtr, + callback, + moveMode, + rate, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + null); + } + + public void moveColorTemperature( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveColorTemperature( + chipClusterPtr, + callback, + moveMode, + rate, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride) { moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void moveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveSaturation(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + public void moveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveHue( + chipClusterPtr, + callback, + moveMode, + rate, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveSaturation( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride) { moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void moveSaturation(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToColor(DefaultClusterCallback callback - , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToColor(DefaultClusterCallback callback - , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToColorTemperature(DefaultClusterCallback callback - , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToColorTemperature(chipClusterPtr, callback, colorTemperature, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToColorTemperature(DefaultClusterCallback callback - , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToColorTemperature(chipClusterPtr, callback, colorTemperature, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToHue(DefaultClusterCallback callback - , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToHue(DefaultClusterCallback callback - , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToHueAndSaturation(DefaultClusterCallback callback - , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToHueAndSaturation(DefaultClusterCallback callback - , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToSaturation(DefaultClusterCallback callback - , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToSaturation(DefaultClusterCallback callback - , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepColor(DefaultClusterCallback callback - , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, null); - } - - public void stepColor(DefaultClusterCallback callback - , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepColorTemperature(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride) { - stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, null); - } - - public void stepColorTemperature(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); - } - - public void stepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepSaturation(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); - } - - public void stepSaturation(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stopMoveStep(DefaultClusterCallback callback - , Integer optionsMask, Integer optionsOverride) { + public void moveSaturation( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveSaturation( + chipClusterPtr, + callback, + moveMode, + rate, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToColor( + DefaultClusterCallback callback, + Integer colorX, + Integer colorY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToColor( + chipClusterPtr, + callback, + colorX, + colorY, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToColor( + DefaultClusterCallback callback, + Integer colorX, + Integer colorY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToColor( + chipClusterPtr, + callback, + colorX, + colorY, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToColorTemperature( + DefaultClusterCallback callback, + Integer colorTemperature, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToColorTemperature( + chipClusterPtr, + callback, + colorTemperature, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToColorTemperature( + DefaultClusterCallback callback, + Integer colorTemperature, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToColorTemperature( + chipClusterPtr, + callback, + colorTemperature, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToHue( + DefaultClusterCallback callback, + Integer hue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToHue( + chipClusterPtr, + callback, + hue, + direction, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToHue( + DefaultClusterCallback callback, + Integer hue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToHue( + chipClusterPtr, + callback, + hue, + direction, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToHueAndSaturation( + DefaultClusterCallback callback, + Integer hue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToHueAndSaturation( + chipClusterPtr, + callback, + hue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToHueAndSaturation( + DefaultClusterCallback callback, + Integer hue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToHueAndSaturation( + chipClusterPtr, + callback, + hue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToSaturation( + DefaultClusterCallback callback, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToSaturation( + chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToSaturation( + DefaultClusterCallback callback, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToSaturation( + chipClusterPtr, + callback, + saturation, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepColor( + DefaultClusterCallback callback, + Integer stepX, + Integer stepY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + stepColor( + chipClusterPtr, + callback, + stepX, + stepY, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void stepColor( + DefaultClusterCallback callback, + Integer stepX, + Integer stepY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepColor( + chipClusterPtr, + callback, + stepX, + stepY, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepColorTemperature( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride) { + stepColorTemperature( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + null); + } + + public void stepColorTemperature( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepColorTemperature( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + stepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void stepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepSaturation( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + stepSaturation( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void stepSaturation( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepSaturation( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stopMoveStep( + DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride) { stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, null); } - public void stopMoveStep(DefaultClusterCallback callback - , Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { + public void stopMoveStep( + DefaultClusterCallback callback, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, timedInvokeTimeoutMs); } - private native void colorLoopSet(long chipClusterPtr, DefaultClusterCallback Callback - , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedMoveHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedMoveToHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedMoveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedStepHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveColor(long chipClusterPtr, DefaultClusterCallback Callback - , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToColor(long chipClusterPtr, DefaultClusterCallback Callback - , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback - , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepColor(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopMoveStep(long chipClusterPtr, DefaultClusterCallback Callback - , Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readCurrentHueAttribute( - IntegerAttributeCallback callback - ) { + private native void colorLoopSet( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer updateFlags, + Integer action, + Integer direction, + Integer time, + Integer startHue, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedMoveHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedMoveToHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer enhancedHue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedMoveToHueAndSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer enhancedHue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedStepHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveColor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer rateX, + Integer rateY, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveColorTemperature( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToColor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer colorX, + Integer colorY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToColorTemperature( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer colorTemperature, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer hue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToHueAndSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer hue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepColor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepX, + Integer stepY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepColorTemperature( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopMoveStep( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readCurrentHueAttribute(IntegerAttributeCallback callback) { readCurrentHueAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentSaturationAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentSaturationAttribute(IntegerAttributeCallback callback) { readCurrentSaturationAttribute(chipClusterPtr, callback); } + public void subscribeCurrentSaturationAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentSaturationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRemainingTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readRemainingTimeAttribute(IntegerAttributeCallback callback) { readRemainingTimeAttribute(chipClusterPtr, callback); } + public void subscribeRemainingTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentXAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentXAttribute(IntegerAttributeCallback callback) { readCurrentXAttribute(chipClusterPtr, callback); } + public void subscribeCurrentXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentYAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentYAttribute(IntegerAttributeCallback callback) { readCurrentYAttribute(chipClusterPtr, callback); } + public void subscribeCurrentYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDriftCompensationAttribute( - IntegerAttributeCallback callback - ) { + public void readDriftCompensationAttribute(IntegerAttributeCallback callback) { readDriftCompensationAttribute(chipClusterPtr, callback); } + public void subscribeDriftCompensationAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeDriftCompensationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCompensationTextAttribute( - CharStringAttributeCallback callback - ) { + public void readCompensationTextAttribute(CharStringAttributeCallback callback) { readCompensationTextAttribute(chipClusterPtr, callback); } + public void subscribeCompensationTextAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeCompensationTextAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTemperatureAttribute( - IntegerAttributeCallback callback - ) { + public void readColorTemperatureAttribute(IntegerAttributeCallback callback) { readColorTemperatureAttribute(chipClusterPtr, callback); } + public void subscribeColorTemperatureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorModeAttribute( - IntegerAttributeCallback callback - ) { + public void readColorModeAttribute(IntegerAttributeCallback callback) { readColorModeAttribute(chipClusterPtr, callback); } + public void subscribeColorModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorControlOptionsAttribute( - IntegerAttributeCallback callback - ) { + public void readColorControlOptionsAttribute(IntegerAttributeCallback callback) { readColorControlOptionsAttribute(chipClusterPtr, callback); } + public void writeColorControlOptionsAttribute(DefaultClusterCallback callback, Integer value) { writeColorControlOptionsAttribute(chipClusterPtr, callback, value, null); } - public void writeColorControlOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorControlOptionsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorControlOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorControlOptionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorControlOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfPrimariesAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfPrimariesAttribute(IntegerAttributeCallback callback) { readNumberOfPrimariesAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfPrimariesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNumberOfPrimariesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary1XAttribute(IntegerAttributeCallback callback) { readPrimary1XAttribute(chipClusterPtr, callback); } + public void subscribePrimary1XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary1XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary1YAttribute(IntegerAttributeCallback callback) { readPrimary1YAttribute(chipClusterPtr, callback); } + public void subscribePrimary1YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary1YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary1IntensityAttribute(IntegerAttributeCallback callback) { readPrimary1IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary1IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary1IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary2XAttribute(IntegerAttributeCallback callback) { readPrimary2XAttribute(chipClusterPtr, callback); } + public void subscribePrimary2XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary2XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary2YAttribute(IntegerAttributeCallback callback) { readPrimary2YAttribute(chipClusterPtr, callback); } + public void subscribePrimary2YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary2YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary2IntensityAttribute(IntegerAttributeCallback callback) { readPrimary2IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary2IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary2IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary3XAttribute(IntegerAttributeCallback callback) { readPrimary3XAttribute(chipClusterPtr, callback); } + public void subscribePrimary3XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary3XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary3YAttribute(IntegerAttributeCallback callback) { readPrimary3YAttribute(chipClusterPtr, callback); } + public void subscribePrimary3YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary3YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary3IntensityAttribute(IntegerAttributeCallback callback) { readPrimary3IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary3IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary3IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary4XAttribute(IntegerAttributeCallback callback) { readPrimary4XAttribute(chipClusterPtr, callback); } + public void subscribePrimary4XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary4XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary4YAttribute(IntegerAttributeCallback callback) { readPrimary4YAttribute(chipClusterPtr, callback); } + public void subscribePrimary4YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary4YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary4IntensityAttribute(IntegerAttributeCallback callback) { readPrimary4IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary4IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary4IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary5XAttribute(IntegerAttributeCallback callback) { readPrimary5XAttribute(chipClusterPtr, callback); } + public void subscribePrimary5XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary5XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary5YAttribute(IntegerAttributeCallback callback) { readPrimary5YAttribute(chipClusterPtr, callback); } + public void subscribePrimary5YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary5YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary5IntensityAttribute(IntegerAttributeCallback callback) { readPrimary5IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary5IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary5IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary6XAttribute(IntegerAttributeCallback callback) { readPrimary6XAttribute(chipClusterPtr, callback); } + public void subscribePrimary6XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary6XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary6YAttribute(IntegerAttributeCallback callback) { readPrimary6YAttribute(chipClusterPtr, callback); } + public void subscribePrimary6YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary6YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary6IntensityAttribute(IntegerAttributeCallback callback) { readPrimary6IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary6IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary6IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWhitePointXAttribute( - IntegerAttributeCallback callback - ) { + public void readWhitePointXAttribute(IntegerAttributeCallback callback) { readWhitePointXAttribute(chipClusterPtr, callback); } + public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value) { writeWhitePointXAttribute(chipClusterPtr, callback, value, null); } - public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWhitePointXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWhitePointXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeWhitePointXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWhitePointXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWhitePointYAttribute( - IntegerAttributeCallback callback - ) { + public void readWhitePointYAttribute(IntegerAttributeCallback callback) { readWhitePointYAttribute(chipClusterPtr, callback); } + public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value) { writeWhitePointYAttribute(chipClusterPtr, callback, value, null); } - public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWhitePointYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWhitePointYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeWhitePointYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWhitePointYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRXAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointRXAttribute(IntegerAttributeCallback callback) { readColorPointRXAttribute(chipClusterPtr, callback); } + public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointRXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointRXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRYAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointRYAttribute(IntegerAttributeCallback callback) { readColorPointRYAttribute(chipClusterPtr, callback); } + public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointRYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointRYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRIntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointRIntensityAttribute(IntegerAttributeCallback callback) { readColorPointRIntensityAttribute(chipClusterPtr, callback); } + public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRIntensityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointRIntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointRIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGXAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointGXAttribute(IntegerAttributeCallback callback) { readColorPointGXAttribute(chipClusterPtr, callback); } + public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointGXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointGXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGYAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointGYAttribute(IntegerAttributeCallback callback) { readColorPointGYAttribute(chipClusterPtr, callback); } + public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointGYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointGYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGIntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointGIntensityAttribute(IntegerAttributeCallback callback) { readColorPointGIntensityAttribute(chipClusterPtr, callback); } + public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGIntensityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointGIntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointGIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBXAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointBXAttribute(IntegerAttributeCallback callback) { readColorPointBXAttribute(chipClusterPtr, callback); } + public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointBXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointBXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBYAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointBYAttribute(IntegerAttributeCallback callback) { readColorPointBYAttribute(chipClusterPtr, callback); } + public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointBYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointBYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBIntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointBIntensityAttribute(IntegerAttributeCallback callback) { readColorPointBIntensityAttribute(chipClusterPtr, callback); } + public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBIntensityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointBIntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointBIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnhancedCurrentHueAttribute( - IntegerAttributeCallback callback - ) { + public void readEnhancedCurrentHueAttribute(IntegerAttributeCallback callback) { readEnhancedCurrentHueAttribute(chipClusterPtr, callback); } + public void subscribeEnhancedCurrentHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnhancedCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnhancedColorModeAttribute( - IntegerAttributeCallback callback - ) { + public void readEnhancedColorModeAttribute(IntegerAttributeCallback callback) { readEnhancedColorModeAttribute(chipClusterPtr, callback); } + public void subscribeEnhancedColorModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnhancedColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopActiveAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopActiveAttribute(IntegerAttributeCallback callback) { readColorLoopActiveAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopActiveAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorLoopActiveAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopDirectionAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopDirectionAttribute(IntegerAttributeCallback callback) { readColorLoopDirectionAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopDirectionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorLoopDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopTimeAttribute(IntegerAttributeCallback callback) { readColorLoopTimeAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorLoopTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopStartEnhancedHueAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopStartEnhancedHueAttribute(IntegerAttributeCallback callback) { readColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopStartEnhancedHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeColorLoopStartEnhancedHueAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopStoredEnhancedHueAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopStoredEnhancedHueAttribute(IntegerAttributeCallback callback) { readColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopStoredEnhancedHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeColorLoopStoredEnhancedHueAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorCapabilitiesAttribute( - IntegerAttributeCallback callback - ) { + public void readColorCapabilitiesAttribute(IntegerAttributeCallback callback) { readColorCapabilitiesAttribute(chipClusterPtr, callback); } + public void subscribeColorCapabilitiesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTempPhysicalMinAttribute( - IntegerAttributeCallback callback - ) { + public void readColorTempPhysicalMinAttribute(IntegerAttributeCallback callback) { readColorTempPhysicalMinAttribute(chipClusterPtr, callback); } + public void subscribeColorTempPhysicalMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorTempPhysicalMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTempPhysicalMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readColorTempPhysicalMaxAttribute(IntegerAttributeCallback callback) { readColorTempPhysicalMaxAttribute(chipClusterPtr, callback); } + public void subscribeColorTempPhysicalMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorTempPhysicalMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCoupleColorTempToLevelMinMiredsAttribute( - IntegerAttributeCallback callback - ) { + public void readCoupleColorTempToLevelMinMiredsAttribute(IntegerAttributeCallback callback) { readCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback); } + public void subscribeCoupleColorTempToLevelMinMiredsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCoupleColorTempToLevelMinMiredsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpColorTemperatureMiredsAttribute( - IntegerAttributeCallback callback - ) { + public void readStartUpColorTemperatureMiredsAttribute(IntegerAttributeCallback callback) { readStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback); } - public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeStartUpColorTemperatureMiredsAttribute( + DefaultClusterCallback callback, Integer value) { writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeStartUpColorTemperatureMiredsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpColorTemperatureMiredsAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeStartUpColorTemperatureMiredsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeStartUpColorTemperatureMiredsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentSaturationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentSaturationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDriftCompensationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeDriftCompensationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCompensationTextAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeCompensationTextAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorControlOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorControlOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorControlOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfPrimariesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfPrimariesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary1XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary1XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary1YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary1YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary1IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary1IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary2XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary2XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary2YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary2YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary2IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary2IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary3XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary3XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary3YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary3YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary3IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary3IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary4XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary4XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary4YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary4YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary4IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary4IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary5XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary5XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary5YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary5YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary5IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary5IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary6XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary6XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary6YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary6YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary6IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary6IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWhitePointXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeWhitePointXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeWhitePointXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWhitePointYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeWhitePointYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeWhitePointYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointRXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointRXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointRXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointRYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointRYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointRYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointRIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointRIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointRIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointGXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointGXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointGXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointGYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointGYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointGYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointGIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointGIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointGIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointBXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointBXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointBXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointBYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointBYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointBYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointBIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointBIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointBIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnhancedCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEnhancedCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnhancedColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEnhancedColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopActiveAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopActiveAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopDirectionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopDirectionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopStartEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopStartEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorTempPhysicalMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorTempPhysicalMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorTempPhysicalMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorTempPhysicalMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + private native void readCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public static class ContentLauncherCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1290L; + private native void subscribeCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public ContentLauncherCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void readCurrentSaturationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - @Override - public native long initWithDevice(long devicePtr, int endpointId); + private native void subscribeCurrentSaturationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void launchContentRequest(LaunchResponseCallback callback - , Boolean autoPlay, String data, ArrayList search) { - launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, null); - } + private native void readRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void launchContentRequest(LaunchResponseCallback callback - , Boolean autoPlay, String data, ArrayList search - , int timedInvokeTimeoutMs) { - launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, timedInvokeTimeoutMs); - } + private native void subscribeRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void launchURLRequest(LaunchResponseCallback callback - , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation) { - launchURLRequest(chipClusterPtr, callback, contentURL, displayString, brandingInformation, null); - } + private native void readCurrentXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void launchURLRequest(LaunchResponseCallback callback - , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation - , int timedInvokeTimeoutMs) { - launchURLRequest(chipClusterPtr, callback, contentURL, displayString, brandingInformation, timedInvokeTimeoutMs); - } - private native void launchContentRequest(long chipClusterPtr, LaunchResponseCallback Callback - , Boolean autoPlay, String data, ArrayList search - , @Nullable Integer timedInvokeTimeoutMs); - private native void launchURLRequest(long chipClusterPtr, LaunchResponseCallback Callback - , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation - , @Nullable Integer timedInvokeTimeoutMs); - public interface LaunchResponseCallback { - void onSuccess(Integer status, String data); + private native void subscribeCurrentXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - void onError(Exception error); - } + private native void readCurrentYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + private native void subscribeCurrentYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public interface AcceptHeaderListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void readDriftCompensationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readAcceptHeaderListAttribute( - AcceptHeaderListAttributeCallback callback - ) { - readAcceptHeaderListAttribute(chipClusterPtr, callback); - } - public void subscribeAcceptHeaderListAttribute( - AcceptHeaderListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAcceptHeaderListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeDriftCompensationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readSupportedStreamingProtocolsAttribute( - LongAttributeCallback callback - ) { - readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback); - } - public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value) { - writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, null); - } + private native void readCompensationTextAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); - public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { - writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); - } - public void subscribeSupportedStreamingProtocolsAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeCompensationTextAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { - readAttributeListAttribute(chipClusterPtr, callback); - } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readColorTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { - readClusterRevisionAttribute(chipClusterPtr, callback); - } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + private native void subscribeColorTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorControlOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorControlOptionsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorControlOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfPrimariesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfPrimariesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary1XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary1XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary1YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary1YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary1IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary1IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary2XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary2XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary2YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary2YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary2IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary2IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary3XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary3XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary3YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary3YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary3IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary3IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary4XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary4XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary4YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary4YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary4IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary4IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary5XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary5XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary5YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary5YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary5IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary5IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary6XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary6XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary6YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary6YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary6IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary6IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWhitePointXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeWhitePointXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeWhitePointXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWhitePointYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeWhitePointYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeWhitePointYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointRXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointRXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointRXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointRYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointRYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointRYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointRIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointRIntensityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointRIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointGXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointGXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointGXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointGYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointGYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointGYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointGIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointGIntensityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointGIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointBXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointBXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointBXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointBYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointBYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointBYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointBIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointBIntensityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointBIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnhancedCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEnhancedCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnhancedColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEnhancedColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopActiveAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopActiveAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopDirectionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopDirectionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopStartEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopStartEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopStoredEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopStoredEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorTempPhysicalMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorTempPhysicalMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCoupleColorTempToLevelMinMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCoupleColorTempToLevelMinMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartUpColorTemperatureMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeStartUpColorTemperatureMiredsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeStartUpColorTemperatureMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class ContentLauncherCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1290L; + + public ContentLauncherCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void launchContentRequest( + LaunchResponseCallback callback, + Boolean autoPlay, + String data, + ArrayList search) { + launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, null); + } + + public void launchContentRequest( + LaunchResponseCallback callback, + Boolean autoPlay, + String data, + ArrayList search, + int timedInvokeTimeoutMs) { + launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, timedInvokeTimeoutMs); + } + + public void launchURLRequest( + LaunchResponseCallback callback, + String contentURL, + String displayString, + ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation) { + launchURLRequest( + chipClusterPtr, callback, contentURL, displayString, brandingInformation, null); + } + + public void launchURLRequest( + LaunchResponseCallback callback, + String contentURL, + String displayString, + ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation, + int timedInvokeTimeoutMs) { + launchURLRequest( + chipClusterPtr, + callback, + contentURL, + displayString, + brandingInformation, + timedInvokeTimeoutMs); + } + + private native void launchContentRequest( + long chipClusterPtr, + LaunchResponseCallback Callback, + Boolean autoPlay, + String data, + ArrayList search, + @Nullable Integer timedInvokeTimeoutMs); + + private native void launchURLRequest( + long chipClusterPtr, + LaunchResponseCallback Callback, + String contentURL, + String displayString, + ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation, + @Nullable Integer timedInvokeTimeoutMs); + + public interface LaunchResponseCallback { + void onSuccess(Integer status, String data); + + void onError(Exception error); + } + + public interface AcceptHeaderListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readAcceptHeaderListAttribute(AcceptHeaderListAttributeCallback callback) { + readAcceptHeaderListAttribute(chipClusterPtr, callback); + } + + public void subscribeAcceptHeaderListAttribute( + AcceptHeaderListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeAcceptHeaderListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedStreamingProtocolsAttribute(LongAttributeCallback callback) { + readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback); + } + + public void writeSupportedStreamingProtocolsAttribute( + DefaultClusterCallback callback, Long value) { + writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSupportedStreamingProtocolsAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeSupportedStreamingProtocolsAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + + public void subscribeSupportedStreamingProtocolsAttribute( + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeSupportedStreamingProtocolsAttribute( + 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 readClusterRevisionAttribute(IntegerAttributeCallback callback) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAcceptHeaderListAttribute(long chipClusterPtr, - AcceptHeaderListAttributeCallback callback - ); - private native void subscribeAcceptHeaderListAttribute(long chipClusterPtr, - AcceptHeaderListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readSupportedStreamingProtocolsAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeSupportedStreamingProtocolsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSupportedStreamingProtocolsAttribute(long chipClusterPtr, - LongAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readAcceptHeaderListAttribute( + long chipClusterPtr, AcceptHeaderListAttributeCallback callback); + + private native void subscribeAcceptHeaderListAttribute( + long chipClusterPtr, + AcceptHeaderListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSupportedStreamingProtocolsAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void writeSupportedStreamingProtocolsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSupportedStreamingProtocolsAttribute( + long chipClusterPtr, LongAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class DescriptorCluster extends BaseChipCluster { @@ -3846,145 +4436,147 @@ public DescriptorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface DeviceListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ServerListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ClientListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface PartsListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface DeviceListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ServerListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ClientListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface PartsListAttributeCallback { + void onSuccess(List valueList); - public void readDeviceListAttribute( - DeviceListAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readDeviceListAttribute(DeviceListAttributeCallback callback) { readDeviceListAttribute(chipClusterPtr, callback); } + public void subscribeDeviceListAttribute( - DeviceListAttributeCallback callback - , - int minInterval, int maxInterval) { + DeviceListAttributeCallback callback, int minInterval, int maxInterval) { subscribeDeviceListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readServerListAttribute( - ServerListAttributeCallback callback - ) { + public void readServerListAttribute(ServerListAttributeCallback callback) { readServerListAttribute(chipClusterPtr, callback); } + public void subscribeServerListAttribute( - ServerListAttributeCallback callback - , - int minInterval, int maxInterval) { + ServerListAttributeCallback callback, int minInterval, int maxInterval) { subscribeServerListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClientListAttribute( - ClientListAttributeCallback callback - ) { + public void readClientListAttribute(ClientListAttributeCallback callback) { readClientListAttribute(chipClusterPtr, callback); } + public void subscribeClientListAttribute( - ClientListAttributeCallback callback - , - int minInterval, int maxInterval) { + ClientListAttributeCallback callback, int minInterval, int maxInterval) { subscribeClientListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartsListAttribute( - PartsListAttributeCallback callback - ) { + public void readPartsListAttribute(PartsListAttributeCallback callback) { readPartsListAttribute(chipClusterPtr, callback); } + public void subscribePartsListAttribute( - PartsListAttributeCallback callback - , - int minInterval, int maxInterval) { + PartsListAttributeCallback callback, int minInterval, int maxInterval) { subscribePartsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readDeviceListAttribute(long chipClusterPtr, - DeviceListAttributeCallback callback - ); - private native void subscribeDeviceListAttribute(long chipClusterPtr, - DeviceListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readServerListAttribute(long chipClusterPtr, - ServerListAttributeCallback callback - ); - private native void subscribeServerListAttribute(long chipClusterPtr, - ServerListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readClientListAttribute(long chipClusterPtr, - ClientListAttributeCallback callback - ); - private native void subscribeClientListAttribute(long chipClusterPtr, - ClientListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readPartsListAttribute(long chipClusterPtr, - PartsListAttributeCallback callback - ); - private native void subscribePartsListAttribute(long chipClusterPtr, - PartsListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readDeviceListAttribute( + long chipClusterPtr, DeviceListAttributeCallback callback); + + private native void subscribeDeviceListAttribute( + long chipClusterPtr, + DeviceListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readServerListAttribute( + long chipClusterPtr, ServerListAttributeCallback callback); + + private native void subscribeServerListAttribute( + long chipClusterPtr, + ServerListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readClientListAttribute( + long chipClusterPtr, ClientListAttributeCallback callback); + + private native void subscribeClientListAttribute( + long chipClusterPtr, + ClientListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPartsListAttribute( + long chipClusterPtr, PartsListAttributeCallback callback); + + private native void subscribePartsListAttribute( + long chipClusterPtr, PartsListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class DiagnosticLogsCluster extends BaseChipCluster { @@ -3997,50 +4589,69 @@ public DiagnosticLogsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void retrieveLogsRequest(RetrieveLogsResponseCallback callback - , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator) { - retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null); - } + public void retrieveLogsRequest( + RetrieveLogsResponseCallback callback, + Integer intent, + Integer requestedProtocol, + byte[] transferFileDesignator) { + retrieveLogsRequest( + chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null); + } + + public void retrieveLogsRequest( + RetrieveLogsResponseCallback callback, + Integer intent, + Integer requestedProtocol, + byte[] transferFileDesignator, + int timedInvokeTimeoutMs) { + retrieveLogsRequest( + chipClusterPtr, + callback, + intent, + requestedProtocol, + transferFileDesignator, + timedInvokeTimeoutMs); + } + + private native void retrieveLogsRequest( + long chipClusterPtr, + RetrieveLogsResponseCallback Callback, + Integer intent, + Integer requestedProtocol, + byte[] transferFileDesignator, + @Nullable Integer timedInvokeTimeoutMs); - public void retrieveLogsRequest(RetrieveLogsResponseCallback callback - , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator - , int timedInvokeTimeoutMs) { - retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, timedInvokeTimeoutMs); - } - private native void retrieveLogsRequest(long chipClusterPtr, RetrieveLogsResponseCallback Callback - , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator - , @Nullable Integer timedInvokeTimeoutMs); public interface RetrieveLogsResponseCallback { void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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); } public static class DoorLockCluster extends BaseChipCluster { @@ -4053,733 +4664,886 @@ public DoorLockCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - - public void clearCredential(DefaultClusterCallback callback - , @Nullable ChipStructs.DoorLockClusterDlCredential credential - , int timedInvokeTimeoutMs) { + public void clearCredential( + DefaultClusterCallback callback, + @Nullable ChipStructs.DoorLockClusterDlCredential credential, + int timedInvokeTimeoutMs) { clearCredential(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); } - - public void clearUser(DefaultClusterCallback callback - , Integer userIndex - , int timedInvokeTimeoutMs) { + public void clearUser( + DefaultClusterCallback callback, Integer userIndex, int timedInvokeTimeoutMs) { clearUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); } - public void clearWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex) { + public void clearWeekDaySchedule( + DefaultClusterCallback callback, Integer weekDayIndex, Integer userIndex) { clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); } - public void clearWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void clearWeekDaySchedule( + DefaultClusterCallback callback, + Integer weekDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); } - public void clearYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex) { + public void clearYearDaySchedule( + DefaultClusterCallback callback, Integer yearDayIndex, Integer userIndex) { clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); } - public void clearYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void clearYearDaySchedule( + DefaultClusterCallback callback, + Integer yearDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); } - public void getCredentialStatus(GetCredentialStatusResponseCallback callback - , ChipStructs.DoorLockClusterDlCredential credential) { + public void getCredentialStatus( + GetCredentialStatusResponseCallback callback, + ChipStructs.DoorLockClusterDlCredential credential) { getCredentialStatus(chipClusterPtr, callback, credential, null); } - public void getCredentialStatus(GetCredentialStatusResponseCallback callback - , ChipStructs.DoorLockClusterDlCredential credential - , int timedInvokeTimeoutMs) { + public void getCredentialStatus( + GetCredentialStatusResponseCallback callback, + ChipStructs.DoorLockClusterDlCredential credential, + int timedInvokeTimeoutMs) { getCredentialStatus(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); } - public void getUser(GetUserResponseCallback callback - , Integer userIndex) { + public void getUser(GetUserResponseCallback callback, Integer userIndex) { getUser(chipClusterPtr, callback, userIndex, null); } - public void getUser(GetUserResponseCallback callback - , Integer userIndex - , int timedInvokeTimeoutMs) { + public void getUser( + GetUserResponseCallback callback, Integer userIndex, int timedInvokeTimeoutMs) { getUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); } - public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback - , Integer weekDayIndex, Integer userIndex) { + public void getWeekDaySchedule( + GetWeekDayScheduleResponseCallback callback, Integer weekDayIndex, Integer userIndex) { getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); } - public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback - , Integer weekDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void getWeekDaySchedule( + GetWeekDayScheduleResponseCallback callback, + Integer weekDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); } - public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback - , Integer yearDayIndex, Integer userIndex) { + public void getYearDaySchedule( + GetYearDayScheduleResponseCallback callback, Integer yearDayIndex, Integer userIndex) { getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); } - public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback - , Integer yearDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void getYearDaySchedule( + GetYearDayScheduleResponseCallback callback, + Integer yearDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); } - - public void lockDoor(DefaultClusterCallback callback - , Optional pinCode - , int timedInvokeTimeoutMs) { + public void lockDoor( + DefaultClusterCallback callback, Optional pinCode, int timedInvokeTimeoutMs) { lockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); } - - public void setCredential(SetCredentialResponseCallback callback - , Integer operationType, ChipStructs.DoorLockClusterDlCredential credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType - , int timedInvokeTimeoutMs) { - setCredential(chipClusterPtr, callback, operationType, credential, credentialData, userIndex, userStatus, userType, timedInvokeTimeoutMs); - } - - - public void setUser(DefaultClusterCallback callback - , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule - , int timedInvokeTimeoutMs) { - setUser(chipClusterPtr, callback, operationType, userIndex, userName, userUniqueId, userStatus, userType, credentialRule, timedInvokeTimeoutMs); - } - - public void setWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute) { - setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, null); - } - - public void setWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute - , int timedInvokeTimeoutMs) { - setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, timedInvokeTimeoutMs); - } - - public void setYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime) { - setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null); - } - - public void setYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime - , int timedInvokeTimeoutMs) { - setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, timedInvokeTimeoutMs); - } - - - public void unlockDoor(DefaultClusterCallback callback - , Optional pinCode - , int timedInvokeTimeoutMs) { + public void setCredential( + SetCredentialResponseCallback callback, + Integer operationType, + ChipStructs.DoorLockClusterDlCredential credential, + byte[] credentialData, + @Nullable Integer userIndex, + @Nullable Integer userStatus, + @Nullable Integer userType, + int timedInvokeTimeoutMs) { + setCredential( + chipClusterPtr, + callback, + operationType, + credential, + credentialData, + userIndex, + userStatus, + userType, + timedInvokeTimeoutMs); + } + + public void setUser( + DefaultClusterCallback callback, + Integer operationType, + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + int timedInvokeTimeoutMs) { + setUser( + chipClusterPtr, + callback, + operationType, + userIndex, + userName, + userUniqueId, + userStatus, + userType, + credentialRule, + timedInvokeTimeoutMs); + } + + public void setWeekDaySchedule( + DefaultClusterCallback callback, + Integer weekDayIndex, + Integer userIndex, + Integer daysMask, + Integer startHour, + Integer startMinute, + Integer endHour, + Integer endMinute) { + setWeekDaySchedule( + chipClusterPtr, + callback, + weekDayIndex, + userIndex, + daysMask, + startHour, + startMinute, + endHour, + endMinute, + null); + } + + public void setWeekDaySchedule( + DefaultClusterCallback callback, + Integer weekDayIndex, + Integer userIndex, + Integer daysMask, + Integer startHour, + Integer startMinute, + Integer endHour, + Integer endMinute, + int timedInvokeTimeoutMs) { + setWeekDaySchedule( + chipClusterPtr, + callback, + weekDayIndex, + userIndex, + daysMask, + startHour, + startMinute, + endHour, + endMinute, + timedInvokeTimeoutMs); + } + + public void setYearDaySchedule( + DefaultClusterCallback callback, + Integer yearDayIndex, + Integer userIndex, + Long localStartTime, + Long localEndTime) { + setYearDaySchedule( + chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null); + } + + public void setYearDaySchedule( + DefaultClusterCallback callback, + Integer yearDayIndex, + Integer userIndex, + Long localStartTime, + Long localEndTime, + int timedInvokeTimeoutMs) { + setYearDaySchedule( + chipClusterPtr, + callback, + yearDayIndex, + userIndex, + localStartTime, + localEndTime, + timedInvokeTimeoutMs); + } + + public void unlockDoor( + DefaultClusterCallback callback, Optional pinCode, int timedInvokeTimeoutMs) { unlockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); } - - public void unlockWithTimeout(DefaultClusterCallback callback - , Integer timeout, Optional pinCode - , int timedInvokeTimeoutMs) { + public void unlockWithTimeout( + DefaultClusterCallback callback, + Integer timeout, + Optional pinCode, + int timedInvokeTimeoutMs) { unlockWithTimeout(chipClusterPtr, callback, timeout, pinCode, timedInvokeTimeoutMs); } - private native void clearCredential(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable ChipStructs.DoorLockClusterDlCredential credential - , @Nullable Integer timedInvokeTimeoutMs); - private native void clearUser(long chipClusterPtr, DefaultClusterCallback Callback - , Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void clearWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer weekDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void clearYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer yearDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void getCredentialStatus(long chipClusterPtr, GetCredentialStatusResponseCallback Callback - , ChipStructs.DoorLockClusterDlCredential credential - , @Nullable Integer timedInvokeTimeoutMs); - private native void getUser(long chipClusterPtr, GetUserResponseCallback Callback - , Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void getWeekDaySchedule(long chipClusterPtr, GetWeekDayScheduleResponseCallback Callback - , Integer weekDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void getYearDaySchedule(long chipClusterPtr, GetYearDayScheduleResponseCallback Callback - , Integer yearDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void lockDoor(long chipClusterPtr, DefaultClusterCallback Callback - , Optional pinCode - , @Nullable Integer timedInvokeTimeoutMs); - private native void setCredential(long chipClusterPtr, SetCredentialResponseCallback Callback - , Integer operationType, ChipStructs.DoorLockClusterDlCredential credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType - , @Nullable Integer timedInvokeTimeoutMs); - private native void setUser(long chipClusterPtr, DefaultClusterCallback Callback - , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule - , @Nullable Integer timedInvokeTimeoutMs); - private native void setWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute - , @Nullable Integer timedInvokeTimeoutMs); - private native void setYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void unlockDoor(long chipClusterPtr, DefaultClusterCallback Callback - , Optional pinCode - , @Nullable Integer timedInvokeTimeoutMs); - private native void unlockWithTimeout(long chipClusterPtr, DefaultClusterCallback Callback - , Integer timeout, Optional pinCode - , @Nullable Integer timedInvokeTimeoutMs); + + private native void clearCredential( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable ChipStructs.DoorLockClusterDlCredential credential, + @Nullable Integer timedInvokeTimeoutMs); + + private native void clearUser( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void clearWeekDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer weekDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void clearYearDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer yearDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getCredentialStatus( + long chipClusterPtr, + GetCredentialStatusResponseCallback Callback, + ChipStructs.DoorLockClusterDlCredential credential, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getUser( + long chipClusterPtr, + GetUserResponseCallback Callback, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getWeekDaySchedule( + long chipClusterPtr, + GetWeekDayScheduleResponseCallback Callback, + Integer weekDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getYearDaySchedule( + long chipClusterPtr, + GetYearDayScheduleResponseCallback Callback, + Integer yearDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void lockDoor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Optional pinCode, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setCredential( + long chipClusterPtr, + SetCredentialResponseCallback Callback, + Integer operationType, + ChipStructs.DoorLockClusterDlCredential credential, + byte[] credentialData, + @Nullable Integer userIndex, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setUser( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer operationType, + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setWeekDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer weekDayIndex, + Integer userIndex, + Integer daysMask, + Integer startHour, + Integer startMinute, + Integer endHour, + Integer endMinute, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setYearDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer yearDayIndex, + Integer userIndex, + Long localStartTime, + Long localEndTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void unlockDoor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Optional pinCode, + @Nullable Integer timedInvokeTimeoutMs); + + private native void unlockWithTimeout( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer timeout, + Optional pinCode, + @Nullable Integer timedInvokeTimeoutMs); + public interface GetCredentialStatusResponseCallback { - void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); + void onSuccess( + Boolean credentialExists, + @Nullable Integer userIndex, + @Nullable Integer nextCredentialIndex); void onError(Exception error); } public interface GetUserResponseCallback { - void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex); + void onSuccess( + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + @Nullable ArrayList credentials, + @Nullable Integer creatorFabricIndex, + @Nullable Integer lastModifiedFabricIndex, + @Nullable Integer nextUserIndex); void onError(Exception error); } public interface GetWeekDayScheduleResponseCallback { - void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute); + void onSuccess( + Integer weekDayIndex, + Integer userIndex, + Integer status, + Optional daysMask, + Optional startHour, + Optional startMinute, + Optional endHour, + Optional endMinute); void onError(Exception error); } public interface GetYearDayScheduleResponseCallback { - void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime); + void onSuccess( + Integer yearDayIndex, + Integer userIndex, + Integer status, + Optional localStartTime, + Optional localEndTime); void onError(Exception error); } public interface SetCredentialResponseCallback { - void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); + void onSuccess( + Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); void onError(Exception error); } + public interface LockStateAttributeCallback { + void onSuccess(@Nullable Integer value); - public interface LockStateAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface DoorStateAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); - public void readLockStateAttribute( - LockStateAttributeCallback callback - ) { - readLockStateAttribute(chipClusterPtr, callback); + default void onSubscriptionEstablished() {} } - public void subscribeLockStateAttribute( - LockStateAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeLockStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + + public interface DoorStateAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void readLockTypeAttribute( - IntegerAttributeCallback callback - ) { - readLockTypeAttribute(chipClusterPtr, callback); + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } + + public void readLockStateAttribute(LockStateAttributeCallback callback) { + readLockStateAttribute(chipClusterPtr, callback); + } + + public void subscribeLockStateAttribute( + LockStateAttributeCallback callback, int minInterval, int maxInterval) { + subscribeLockStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLockTypeAttribute(IntegerAttributeCallback callback) { + readLockTypeAttribute(chipClusterPtr, callback); + } + public void subscribeLockTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLockTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActuatorEnabledAttribute( - BooleanAttributeCallback callback - ) { + public void readActuatorEnabledAttribute(BooleanAttributeCallback callback) { readActuatorEnabledAttribute(chipClusterPtr, callback); } + public void subscribeActuatorEnabledAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeActuatorEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDoorStateAttribute( - DoorStateAttributeCallback callback - ) { + public void readDoorStateAttribute(DoorStateAttributeCallback callback) { readDoorStateAttribute(chipClusterPtr, callback); } + public void subscribeDoorStateAttribute( - DoorStateAttributeCallback callback - , - int minInterval, int maxInterval) { + DoorStateAttributeCallback callback, int minInterval, int maxInterval) { subscribeDoorStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfTotalUsersSupportedAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfTotalUsersSupportedAttribute(IntegerAttributeCallback callback) { readNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfTotalUsersSupportedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfTotalUsersSupportedAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfPINUsersSupportedAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfPINUsersSupportedAttribute(IntegerAttributeCallback callback) { readNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfPINUsersSupportedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfPINUsersSupportedAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfRFIDUsersSupportedAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfRFIDUsersSupportedAttribute(IntegerAttributeCallback callback) { readNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfRFIDUsersSupportedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfRFIDUsersSupportedAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNumberOfWeekDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback - ) { + IntegerAttributeCallback callback) { readNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNumberOfYearDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback - ) { + IntegerAttributeCallback callback) { readNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxPINCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxPINCodeLengthAttribute(IntegerAttributeCallback callback) { readMaxPINCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMaxPINCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinPINCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMinPINCodeLengthAttribute(IntegerAttributeCallback callback) { readMinPINCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMinPINCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxRFIDCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxRFIDCodeLengthAttribute(IntegerAttributeCallback callback) { readMaxRFIDCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMaxRFIDCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinRFIDCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMinRFIDCodeLengthAttribute(IntegerAttributeCallback callback) { readMinRFIDCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMinRFIDCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLanguageAttribute( - CharStringAttributeCallback callback - ) { + public void readLanguageAttribute(CharStringAttributeCallback callback) { readLanguageAttribute(chipClusterPtr, callback); } + public void writeLanguageAttribute(DefaultClusterCallback callback, String value) { writeLanguageAttribute(chipClusterPtr, callback, value, null); } - public void writeLanguageAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLanguageAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLanguageAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLanguageAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLanguageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAutoRelockTimeAttribute( - LongAttributeCallback callback - ) { + public void readAutoRelockTimeAttribute(LongAttributeCallback callback) { readAutoRelockTimeAttribute(chipClusterPtr, callback); } + public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value) { writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeAutoRelockTimeAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeAutoRelockTimeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeAutoRelockTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoundVolumeAttribute( - IntegerAttributeCallback callback - ) { + public void readSoundVolumeAttribute(IntegerAttributeCallback callback) { readSoundVolumeAttribute(chipClusterPtr, callback); } + public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value) { writeSoundVolumeAttribute(chipClusterPtr, callback, value, null); } - public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSoundVolumeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSoundVolumeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeSoundVolumeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSoundVolumeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperatingModeAttribute( - IntegerAttributeCallback callback - ) { + public void readOperatingModeAttribute(IntegerAttributeCallback callback) { readOperatingModeAttribute(chipClusterPtr, callback); } + public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value) { writeOperatingModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOperatingModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOperatingModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOperatingModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOperatingModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedOperatingModesAttribute( - IntegerAttributeCallback callback - ) { + public void readSupportedOperatingModesAttribute(IntegerAttributeCallback callback) { readSupportedOperatingModesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedOperatingModesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedOperatingModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnableOneTouchLockingAttribute( - BooleanAttributeCallback callback - ) { + public void readEnableOneTouchLockingAttribute(BooleanAttributeCallback callback) { readEnableOneTouchLockingAttribute(chipClusterPtr, callback); } - public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value) { + + public void writeEnableOneTouchLockingAttribute( + DefaultClusterCallback callback, Boolean value) { writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, null); } - public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeEnableOneTouchLockingAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnableOneTouchLockingAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnableOneTouchLockingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnablePrivacyModeButtonAttribute( - BooleanAttributeCallback callback - ) { + public void readEnablePrivacyModeButtonAttribute(BooleanAttributeCallback callback) { readEnablePrivacyModeButtonAttribute(chipClusterPtr, callback); } - public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value) { + + public void writeEnablePrivacyModeButtonAttribute( + DefaultClusterCallback callback, Boolean value) { writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, null); } - public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeEnablePrivacyModeButtonAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnablePrivacyModeButtonAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWrongCodeEntryLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readWrongCodeEntryLimitAttribute(IntegerAttributeCallback callback) { readWrongCodeEntryLimitAttribute(chipClusterPtr, callback); } + public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value) { writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWrongCodeEntryLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeWrongCodeEntryLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLockStateAttribute(long chipClusterPtr, - LockStateAttributeCallback callback - ); - private native void subscribeLockStateAttribute(long chipClusterPtr, - LockStateAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readLockTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLockTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActuatorEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeActuatorEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDoorStateAttribute(long chipClusterPtr, - DoorStateAttributeCallback callback - ); - private native void subscribeDoorStateAttribute(long chipClusterPtr, - DoorStateAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfPINUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfPINUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLanguageAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeLanguageAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLanguageAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAutoRelockTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeAutoRelockTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeAutoRelockTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSoundVolumeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeSoundVolumeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSoundVolumeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOperatingModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOperatingModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOperatingModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedOperatingModesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSupportedOperatingModesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnableOneTouchLockingAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeEnableOneTouchLockingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnableOneTouchLockingAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnablePrivacyModeButtonAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeEnablePrivacyModeButtonAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnablePrivacyModeButtonAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWrongCodeEntryLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeWrongCodeEntryLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeWrongCodeEntryLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readLockStateAttribute( + long chipClusterPtr, LockStateAttributeCallback callback); + + private native void subscribeLockStateAttribute( + long chipClusterPtr, LockStateAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLockTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLockTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActuatorEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeActuatorEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDoorStateAttribute( + long chipClusterPtr, DoorStateAttributeCallback callback); + + private native void subscribeDoorStateAttribute( + long chipClusterPtr, DoorStateAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfTotalUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfTotalUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfPINUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfPINUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfRFIDUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfRFIDUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfWeekDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfYearDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLanguageAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeLanguageAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLanguageAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readAutoRelockTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void writeAutoRelockTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeAutoRelockTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSoundVolumeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeSoundVolumeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSoundVolumeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOperatingModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOperatingModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOperatingModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSupportedOperatingModesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSupportedOperatingModesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnableOneTouchLockingAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeEnableOneTouchLockingAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnableOneTouchLockingAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnablePrivacyModeButtonAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeEnablePrivacyModeButtonAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnablePrivacyModeButtonAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWrongCodeEntryLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeWrongCodeEntryLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeWrongCodeEntryLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ElectricalMeasurementCluster extends BaseChipCluster { @@ -4792,258 +5556,211 @@ public ElectricalMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readMeasurementTypeAttribute( - LongAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMeasurementTypeAttribute(LongAttributeCallback callback) { readMeasurementTypeAttribute(chipClusterPtr, callback); } + public void subscribeMeasurementTypeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasurementTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTotalActivePowerAttribute( - LongAttributeCallback callback - ) { + public void readTotalActivePowerAttribute(LongAttributeCallback callback) { readTotalActivePowerAttribute(chipClusterPtr, callback); } + public void subscribeTotalActivePowerAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTotalActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsVoltageAttribute(IntegerAttributeCallback callback) { readRmsVoltageAttribute(chipClusterPtr, callback); } + public void subscribeRmsVoltageAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageMinAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsVoltageMinAttribute(IntegerAttributeCallback callback) { readRmsVoltageMinAttribute(chipClusterPtr, callback); } + public void subscribeRmsVoltageMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsVoltageMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsVoltageMaxAttribute(IntegerAttributeCallback callback) { readRmsVoltageMaxAttribute(chipClusterPtr, callback); } + public void subscribeRmsVoltageMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsVoltageMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsCurrentAttribute(IntegerAttributeCallback callback) { readRmsCurrentAttribute(chipClusterPtr, callback); } + public void subscribeRmsCurrentAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentMinAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsCurrentMinAttribute(IntegerAttributeCallback callback) { readRmsCurrentMinAttribute(chipClusterPtr, callback); } + public void subscribeRmsCurrentMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsCurrentMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsCurrentMaxAttribute(IntegerAttributeCallback callback) { readRmsCurrentMaxAttribute(chipClusterPtr, callback); } + public void subscribeRmsCurrentMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsCurrentMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerAttribute( - IntegerAttributeCallback callback - ) { + public void readActivePowerAttribute(IntegerAttributeCallback callback) { readActivePowerAttribute(chipClusterPtr, callback); } + public void subscribeActivePowerAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerMinAttribute( - IntegerAttributeCallback callback - ) { + public void readActivePowerMinAttribute(IntegerAttributeCallback callback) { readActivePowerMinAttribute(chipClusterPtr, callback); } + public void subscribeActivePowerMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActivePowerMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readActivePowerMaxAttribute(IntegerAttributeCallback callback) { readActivePowerMaxAttribute(chipClusterPtr, callback); } + public void subscribeActivePowerMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActivePowerMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasurementTypeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeMeasurementTypeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTotalActivePowerAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTotalActivePowerAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsVoltageAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsVoltageAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsVoltageMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsVoltageMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsVoltageMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsVoltageMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsCurrentAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsCurrentAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsCurrentMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsCurrentMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsCurrentMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsCurrentMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActivePowerAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeActivePowerAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActivePowerMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeActivePowerMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActivePowerMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeActivePowerMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasurementTypeAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeMeasurementTypeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTotalActivePowerAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTotalActivePowerAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsVoltageAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsVoltageAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsVoltageMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsVoltageMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsVoltageMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsVoltageMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsCurrentAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsCurrentAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsCurrentMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsCurrentMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsCurrentMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsCurrentMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActivePowerAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeActivePowerAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActivePowerMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeActivePowerMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActivePowerMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeActivePowerMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class EthernetNetworkDiagnosticsCluster extends BaseChipCluster { @@ -5056,253 +5773,210 @@ public EthernetNetworkDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetCounts(DefaultClusterCallback callback - ) { + public void resetCounts(DefaultClusterCallback callback) { resetCounts(chipClusterPtr, callback, null); } - public void resetCounts(DefaultClusterCallback callback + public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void resetCounts( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readPHYRateAttribute( - IntegerAttributeCallback callback - ) { + public void readPHYRateAttribute(IntegerAttributeCallback callback) { readPHYRateAttribute(chipClusterPtr, callback); } + public void subscribePHYRateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePHYRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFullDuplexAttribute( - BooleanAttributeCallback callback - ) { + public void readFullDuplexAttribute(BooleanAttributeCallback callback) { readFullDuplexAttribute(chipClusterPtr, callback); } + public void subscribeFullDuplexAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeFullDuplexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketRxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketRxCountAttribute(LongAttributeCallback callback) { readPacketRxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketTxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketTxCountAttribute(LongAttributeCallback callback) { readPacketTxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketTxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrCountAttribute(LongAttributeCallback callback) { readTxErrCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCollisionCountAttribute( - LongAttributeCallback callback - ) { + public void readCollisionCountAttribute(LongAttributeCallback callback) { readCollisionCountAttribute(chipClusterPtr, callback); } + public void subscribeCollisionCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCollisionCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute( - LongAttributeCallback callback - ) { + public void readOverrunCountAttribute(LongAttributeCallback callback) { readOverrunCountAttribute(chipClusterPtr, callback); } + public void subscribeOverrunCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCarrierDetectAttribute( - BooleanAttributeCallback callback - ) { + public void readCarrierDetectAttribute(BooleanAttributeCallback callback) { readCarrierDetectAttribute(chipClusterPtr, callback); } + public void subscribeCarrierDetectAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeCarrierDetectAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTimeSinceResetAttribute( - LongAttributeCallback callback - ) { + public void readTimeSinceResetAttribute(LongAttributeCallback callback) { readTimeSinceResetAttribute(chipClusterPtr, callback); } + public void subscribeTimeSinceResetAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTimeSinceResetAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readPHYRateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePHYRateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readFullDuplexAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeFullDuplexAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCollisionCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCollisionCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCarrierDetectAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeCarrierDetectAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTimeSinceResetAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTimeSinceResetAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readPHYRateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePHYRateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFullDuplexAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeFullDuplexAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCollisionCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCollisionCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCarrierDetectAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeCarrierDetectAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTimeSinceResetAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTimeSinceResetAttribute( + long chipClusterPtr, LongAttributeCallback 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 FixedLabelCluster extends BaseChipCluster { @@ -5315,73 +5989,69 @@ public FixedLabelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LabelListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface LabelListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readLabelListAttribute( - LabelListAttributeCallback callback - ) { + public void readLabelListAttribute(LabelListAttributeCallback callback) { readLabelListAttribute(chipClusterPtr, callback); } + public void subscribeLabelListAttribute( - LabelListAttributeCallback callback - , - int minInterval, int maxInterval) { + LabelListAttributeCallback callback, int minInterval, int maxInterval) { subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback callback - ); - private native void subscribeLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback callback); + + private native void subscribeLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class FlowMeasurementCluster extends BaseChipCluster { @@ -5394,125 +6064,106 @@ public FlowMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { + public void readToleranceAttribute(IntegerAttributeCallback callback) { readToleranceAttribute(chipClusterPtr, callback); } + public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GeneralCommissioningCluster extends BaseChipCluster { @@ -5525,47 +6176,88 @@ public GeneralCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void armFailSafe(ArmFailSafeResponseCallback callback - , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs) { + public void armFailSafe( + ArmFailSafeResponseCallback callback, + Integer expiryLengthSeconds, + Long breadcrumb, + Long timeoutMs) { armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timeoutMs, null); } - public void armFailSafe(ArmFailSafeResponseCallback callback - , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs - , int timedInvokeTimeoutMs) { - armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timeoutMs, timedInvokeTimeoutMs); + public void armFailSafe( + ArmFailSafeResponseCallback callback, + Integer expiryLengthSeconds, + Long breadcrumb, + Long timeoutMs, + int timedInvokeTimeoutMs) { + armFailSafe( + chipClusterPtr, + callback, + expiryLengthSeconds, + breadcrumb, + timeoutMs, + timedInvokeTimeoutMs); } - public void commissioningComplete(CommissioningCompleteResponseCallback callback - ) { + public void commissioningComplete(CommissioningCompleteResponseCallback callback) { commissioningComplete(chipClusterPtr, callback, null); } - public void commissioningComplete(CommissioningCompleteResponseCallback callback + public void commissioningComplete( + CommissioningCompleteResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { commissioningComplete(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback - , Integer location, String countryCode, Long breadcrumb, Long timeoutMs) { - setRegulatoryConfig(chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, null); - } - - public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback - , Integer location, String countryCode, Long breadcrumb, Long timeoutMs - , int timedInvokeTimeoutMs) { - setRegulatoryConfig(chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, timedInvokeTimeoutMs); - } - private native void armFailSafe(long chipClusterPtr, ArmFailSafeResponseCallback Callback - , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs - , @Nullable Integer timedInvokeTimeoutMs); - private native void commissioningComplete(long chipClusterPtr, CommissioningCompleteResponseCallback Callback + public void setRegulatoryConfig( + SetRegulatoryConfigResponseCallback callback, + Integer location, + String countryCode, + Long breadcrumb, + Long timeoutMs) { + setRegulatoryConfig( + chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, null); + } + + public void setRegulatoryConfig( + SetRegulatoryConfigResponseCallback callback, + Integer location, + String countryCode, + Long breadcrumb, + Long timeoutMs, + int timedInvokeTimeoutMs) { + setRegulatoryConfig( + chipClusterPtr, + callback, + location, + countryCode, + breadcrumb, + timeoutMs, + timedInvokeTimeoutMs); + } + + private native void armFailSafe( + long chipClusterPtr, + ArmFailSafeResponseCallback Callback, + Integer expiryLengthSeconds, + Long breadcrumb, + Long timeoutMs, + @Nullable Integer timedInvokeTimeoutMs); + + private native void commissioningComplete( + long chipClusterPtr, + CommissioningCompleteResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setRegulatoryConfig( + long chipClusterPtr, + SetRegulatoryConfigResponseCallback Callback, + Integer location, + String countryCode, + Long breadcrumb, + Long timeoutMs, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void setRegulatoryConfig(long chipClusterPtr, SetRegulatoryConfigResponseCallback Callback - , Integer location, String countryCode, Long breadcrumb, Long timeoutMs - , @Nullable Integer timedInvokeTimeoutMs); public interface ArmFailSafeResponseCallback { void onSuccess(Integer errorCode, String debugText); @@ -5584,140 +6276,135 @@ public interface SetRegulatoryConfigResponseCallback { void onError(Exception error); } + public interface BasicCommissioningInfoListAttributeCallback { + void onSuccess( + List valueList); - public interface BasicCommissioningInfoListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readBreadcrumbAttribute( - LongAttributeCallback callback - ) { + public void readBreadcrumbAttribute(LongAttributeCallback callback) { readBreadcrumbAttribute(chipClusterPtr, callback); } + public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value) { writeBreadcrumbAttribute(chipClusterPtr, callback, value, null); } - public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBreadcrumbAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBreadcrumbAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBreadcrumbAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBreadcrumbAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readBasicCommissioningInfoListAttribute( - BasicCommissioningInfoListAttributeCallback callback - ) { + BasicCommissioningInfoListAttributeCallback callback) { readBasicCommissioningInfoListAttribute(chipClusterPtr, callback); } + public void subscribeBasicCommissioningInfoListAttribute( - BasicCommissioningInfoListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeBasicCommissioningInfoListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + BasicCommissioningInfoListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeBasicCommissioningInfoListAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readRegulatoryConfigAttribute( - IntegerAttributeCallback callback - ) { + public void readRegulatoryConfigAttribute(IntegerAttributeCallback callback) { readRegulatoryConfigAttribute(chipClusterPtr, callback); } + public void subscribeRegulatoryConfigAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRegulatoryConfigAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocationCapabilityAttribute( - IntegerAttributeCallback callback - ) { + public void readLocationCapabilityAttribute(IntegerAttributeCallback callback) { readLocationCapabilityAttribute(chipClusterPtr, callback); } + public void subscribeLocationCapabilityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocationCapabilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBreadcrumbAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeBreadcrumbAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBreadcrumbAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBasicCommissioningInfoListAttribute(long chipClusterPtr, - BasicCommissioningInfoListAttributeCallback callback - ); - private native void subscribeBasicCommissioningInfoListAttribute(long chipClusterPtr, - BasicCommissioningInfoListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readRegulatoryConfigAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRegulatoryConfigAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLocationCapabilityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLocationCapabilityAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readBreadcrumbAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void writeBreadcrumbAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBreadcrumbAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBasicCommissioningInfoListAttribute( + long chipClusterPtr, BasicCommissioningInfoListAttributeCallback callback); + + private native void subscribeBasicCommissioningInfoListAttribute( + long chipClusterPtr, + BasicCommissioningInfoListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readRegulatoryConfigAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRegulatoryConfigAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLocationCapabilityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLocationCapabilityAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GeneralDiagnosticsCluster extends BaseChipCluster { @@ -5730,221 +6417,209 @@ public GeneralDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface NetworkInterfacesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveHardwareFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveRadioFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveNetworkFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface NetworkInterfacesAttributeCallback { + void onSuccess(List valueList); - public void readNetworkInterfacesAttribute( - NetworkInterfacesAttributeCallback callback - ) { - readNetworkInterfacesAttribute(chipClusterPtr, callback); - } - public void subscribeNetworkInterfacesAttribute( - NetworkInterfacesAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + void onError(Exception ex); - public void readRebootCountAttribute( - IntegerAttributeCallback callback - ) { - readRebootCountAttribute(chipClusterPtr, callback); + default void onSubscriptionEstablished() {} } - public void subscribeRebootCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeRebootCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + + public interface ActiveHardwareFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void readUpTimeAttribute( - LongAttributeCallback callback - ) { + public interface ActiveRadioFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ActiveNetworkFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readNetworkInterfacesAttribute(NetworkInterfacesAttributeCallback callback) { + readNetworkInterfacesAttribute(chipClusterPtr, callback); + } + + public void subscribeNetworkInterfacesAttribute( + NetworkInterfacesAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRebootCountAttribute(IntegerAttributeCallback callback) { + readRebootCountAttribute(chipClusterPtr, callback); + } + + public void subscribeRebootCountAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeRebootCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUpTimeAttribute(LongAttributeCallback callback) { readUpTimeAttribute(chipClusterPtr, callback); } + public void subscribeUpTimeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTotalOperationalHoursAttribute( - LongAttributeCallback callback - ) { + public void readTotalOperationalHoursAttribute(LongAttributeCallback callback) { readTotalOperationalHoursAttribute(chipClusterPtr, callback); } + public void subscribeTotalOperationalHoursAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTotalOperationalHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBootReasonsAttribute( - IntegerAttributeCallback callback - ) { + public void readBootReasonsAttribute(IntegerAttributeCallback callback) { readBootReasonsAttribute(chipClusterPtr, callback); } + public void subscribeBootReasonsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBootReasonsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveHardwareFaultsAttribute( - ActiveHardwareFaultsAttributeCallback callback - ) { + public void readActiveHardwareFaultsAttribute(ActiveHardwareFaultsAttributeCallback callback) { readActiveHardwareFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveHardwareFaultsAttribute( - ActiveHardwareFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveHardwareFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveHardwareFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveRadioFaultsAttribute( - ActiveRadioFaultsAttributeCallback callback - ) { + public void readActiveRadioFaultsAttribute(ActiveRadioFaultsAttributeCallback callback) { readActiveRadioFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveRadioFaultsAttribute( - ActiveRadioFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveRadioFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveRadioFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveNetworkFaultsAttribute( - ActiveNetworkFaultsAttributeCallback callback - ) { + public void readActiveNetworkFaultsAttribute(ActiveNetworkFaultsAttributeCallback callback) { readActiveNetworkFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveNetworkFaultsAttribute( - ActiveNetworkFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveNetworkFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveNetworkFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNetworkInterfacesAttribute(long chipClusterPtr, - NetworkInterfacesAttributeCallback callback - ); - private native void subscribeNetworkInterfacesAttribute(long chipClusterPtr, - NetworkInterfacesAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readRebootCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRebootCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUpTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeUpTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTotalOperationalHoursAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTotalOperationalHoursAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBootReasonsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBootReasonsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveHardwareFaultsAttribute(long chipClusterPtr, - ActiveHardwareFaultsAttributeCallback callback - ); - private native void subscribeActiveHardwareFaultsAttribute(long chipClusterPtr, - ActiveHardwareFaultsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readActiveRadioFaultsAttribute(long chipClusterPtr, - ActiveRadioFaultsAttributeCallback callback - ); - private native void subscribeActiveRadioFaultsAttribute(long chipClusterPtr, - ActiveRadioFaultsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readActiveNetworkFaultsAttribute(long chipClusterPtr, - ActiveNetworkFaultsAttributeCallback callback - ); - private native void subscribeActiveNetworkFaultsAttribute(long chipClusterPtr, - ActiveNetworkFaultsAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readNetworkInterfacesAttribute( + long chipClusterPtr, NetworkInterfacesAttributeCallback callback); + + private native void subscribeNetworkInterfacesAttribute( + long chipClusterPtr, + NetworkInterfacesAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readRebootCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRebootCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUpTimeAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeUpTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTotalOperationalHoursAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTotalOperationalHoursAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBootReasonsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBootReasonsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveHardwareFaultsAttribute( + long chipClusterPtr, ActiveHardwareFaultsAttributeCallback callback); + + private native void subscribeActiveHardwareFaultsAttribute( + long chipClusterPtr, + ActiveHardwareFaultsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readActiveRadioFaultsAttribute( + long chipClusterPtr, ActiveRadioFaultsAttributeCallback callback); + + private native void subscribeActiveRadioFaultsAttribute( + long chipClusterPtr, + ActiveRadioFaultsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readActiveNetworkFaultsAttribute( + long chipClusterPtr, ActiveNetworkFaultsAttributeCallback callback); + + private native void subscribeActiveNetworkFaultsAttribute( + long chipClusterPtr, + ActiveNetworkFaultsAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GroupKeyManagementCluster extends BaseChipCluster { @@ -5957,61 +6632,73 @@ public GroupKeyManagementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void keySetRead(KeySetReadResponseCallback callback - , Integer groupKeySetID) { + public void keySetRead(KeySetReadResponseCallback callback, Integer groupKeySetID) { keySetRead(chipClusterPtr, callback, groupKeySetID, null); } - public void keySetRead(KeySetReadResponseCallback callback - , Integer groupKeySetID - , int timedInvokeTimeoutMs) { + public void keySetRead( + KeySetReadResponseCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) { keySetRead(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); } - public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback - , ArrayList groupKeySetIDs) { + public void keySetReadAllIndices( + KeySetReadAllIndicesResponseCallback callback, ArrayList groupKeySetIDs) { keySetReadAllIndices(chipClusterPtr, callback, groupKeySetIDs, null); } - public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback - , ArrayList groupKeySetIDs - , int timedInvokeTimeoutMs) { + public void keySetReadAllIndices( + KeySetReadAllIndicesResponseCallback callback, + ArrayList groupKeySetIDs, + int timedInvokeTimeoutMs) { keySetReadAllIndices(chipClusterPtr, callback, groupKeySetIDs, timedInvokeTimeoutMs); } - public void keySetRemove(DefaultClusterCallback callback - , Integer groupKeySetID) { + public void keySetRemove(DefaultClusterCallback callback, Integer groupKeySetID) { keySetRemove(chipClusterPtr, callback, groupKeySetID, null); } - public void keySetRemove(DefaultClusterCallback callback - , Integer groupKeySetID - , int timedInvokeTimeoutMs) { + public void keySetRemove( + DefaultClusterCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) { keySetRemove(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); } - public void keySetWrite(DefaultClusterCallback callback - , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { + public void keySetWrite( + DefaultClusterCallback callback, + ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { keySetWrite(chipClusterPtr, callback, groupKeySet, null); } - public void keySetWrite(DefaultClusterCallback callback - , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet - , int timedInvokeTimeoutMs) { + public void keySetWrite( + DefaultClusterCallback callback, + ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet, + int timedInvokeTimeoutMs) { keySetWrite(chipClusterPtr, callback, groupKeySet, timedInvokeTimeoutMs); } - private native void keySetRead(long chipClusterPtr, KeySetReadResponseCallback Callback - , Integer groupKeySetID - , @Nullable Integer timedInvokeTimeoutMs); - private native void keySetReadAllIndices(long chipClusterPtr, KeySetReadAllIndicesResponseCallback Callback - , ArrayList groupKeySetIDs - , @Nullable Integer timedInvokeTimeoutMs); - private native void keySetRemove(long chipClusterPtr, DefaultClusterCallback Callback - , Integer groupKeySetID - , @Nullable Integer timedInvokeTimeoutMs); - private native void keySetWrite(long chipClusterPtr, DefaultClusterCallback Callback - , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet - , @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetRead( + long chipClusterPtr, + KeySetReadResponseCallback Callback, + Integer groupKeySetID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetReadAllIndices( + long chipClusterPtr, + KeySetReadAllIndicesResponseCallback Callback, + ArrayList groupKeySetIDs, + @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetRemove( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer groupKeySetID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetWrite( + long chipClusterPtr, + DefaultClusterCallback Callback, + ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet, + @Nullable Integer timedInvokeTimeoutMs); + public interface KeySetReadAllIndicesResponseCallback { void onSuccess(ArrayList groupKeySetIDs); @@ -6024,136 +6711,128 @@ public interface KeySetReadResponseCallback { void onError(Exception error); } + public interface GroupKeyMapAttributeCallback { + void onSuccess(List valueList); - public interface GroupKeyMapAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface GroupTableAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface GroupTableAttributeCallback { + void onSuccess(List valueList); - public void readGroupKeyMapAttribute( - GroupKeyMapAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readGroupKeyMapAttribute(GroupKeyMapAttributeCallback callback) { readGroupKeyMapAttribute(chipClusterPtr, callback); } + public void subscribeGroupKeyMapAttribute( - GroupKeyMapAttributeCallback callback - , - int minInterval, int maxInterval) { + GroupKeyMapAttributeCallback callback, int minInterval, int maxInterval) { subscribeGroupKeyMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGroupTableAttribute( - GroupTableAttributeCallback callback - ) { + public void readGroupTableAttribute(GroupTableAttributeCallback callback) { readGroupTableAttribute(chipClusterPtr, callback); } + public void subscribeGroupTableAttribute( - GroupTableAttributeCallback callback - , - int minInterval, int maxInterval) { + GroupTableAttributeCallback callback, int minInterval, int maxInterval) { subscribeGroupTableAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxGroupsPerFabricAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxGroupsPerFabricAttribute(IntegerAttributeCallback callback) { readMaxGroupsPerFabricAttribute(chipClusterPtr, callback); } + public void subscribeMaxGroupsPerFabricAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxGroupsPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxGroupKeysPerFabricAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxGroupKeysPerFabricAttribute(IntegerAttributeCallback callback) { readMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback); } + public void subscribeMaxGroupKeysPerFabricAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readGroupKeyMapAttribute(long chipClusterPtr, - GroupKeyMapAttributeCallback callback - ); - private native void subscribeGroupKeyMapAttribute(long chipClusterPtr, - GroupKeyMapAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readGroupTableAttribute(long chipClusterPtr, - GroupTableAttributeCallback callback - ); - private native void subscribeGroupTableAttribute(long chipClusterPtr, - GroupTableAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readMaxGroupsPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxGroupsPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxGroupKeysPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxGroupKeysPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readGroupKeyMapAttribute( + long chipClusterPtr, GroupKeyMapAttributeCallback callback); + + private native void subscribeGroupKeyMapAttribute( + long chipClusterPtr, + GroupKeyMapAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readGroupTableAttribute( + long chipClusterPtr, GroupTableAttributeCallback callback); + + private native void subscribeGroupTableAttribute( + long chipClusterPtr, + GroupTableAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readMaxGroupsPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxGroupsPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxGroupKeysPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxGroupKeysPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GroupsCluster extends BaseChipCluster { @@ -6166,89 +6845,107 @@ public GroupsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addGroup(AddGroupResponseCallback callback - , Integer groupId, String groupName) { + public void addGroup(AddGroupResponseCallback callback, Integer groupId, String groupName) { addGroup(chipClusterPtr, callback, groupId, groupName, null); } - public void addGroup(AddGroupResponseCallback callback - , Integer groupId, String groupName - , int timedInvokeTimeoutMs) { + public void addGroup( + AddGroupResponseCallback callback, + Integer groupId, + String groupName, + int timedInvokeTimeoutMs) { addGroup(chipClusterPtr, callback, groupId, groupName, timedInvokeTimeoutMs); } - public void addGroupIfIdentifying(DefaultClusterCallback callback - , Integer groupId, String groupName) { + public void addGroupIfIdentifying( + DefaultClusterCallback callback, Integer groupId, String groupName) { addGroupIfIdentifying(chipClusterPtr, callback, groupId, groupName, null); } - public void addGroupIfIdentifying(DefaultClusterCallback callback - , Integer groupId, String groupName - , int timedInvokeTimeoutMs) { + public void addGroupIfIdentifying( + DefaultClusterCallback callback, + Integer groupId, + String groupName, + int timedInvokeTimeoutMs) { addGroupIfIdentifying(chipClusterPtr, callback, groupId, groupName, timedInvokeTimeoutMs); } - public void getGroupMembership(GetGroupMembershipResponseCallback callback - , ArrayList groupList) { + public void getGroupMembership( + GetGroupMembershipResponseCallback callback, ArrayList groupList) { getGroupMembership(chipClusterPtr, callback, groupList, null); } - public void getGroupMembership(GetGroupMembershipResponseCallback callback - , ArrayList groupList - , int timedInvokeTimeoutMs) { + public void getGroupMembership( + GetGroupMembershipResponseCallback callback, + ArrayList groupList, + int timedInvokeTimeoutMs) { getGroupMembership(chipClusterPtr, callback, groupList, timedInvokeTimeoutMs); } - public void removeAllGroups(DefaultClusterCallback callback - ) { + public void removeAllGroups(DefaultClusterCallback callback) { removeAllGroups(chipClusterPtr, callback, null); } - public void removeAllGroups(DefaultClusterCallback callback + public void removeAllGroups(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { removeAllGroups(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void removeGroup(RemoveGroupResponseCallback callback - , Integer groupId) { + public void removeGroup(RemoveGroupResponseCallback callback, Integer groupId) { removeGroup(chipClusterPtr, callback, groupId, null); } - public void removeGroup(RemoveGroupResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void removeGroup( + RemoveGroupResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { removeGroup(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void viewGroup(ViewGroupResponseCallback callback - , Integer groupId) { + public void viewGroup(ViewGroupResponseCallback callback, Integer groupId) { viewGroup(chipClusterPtr, callback, groupId, null); } - public void viewGroup(ViewGroupResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void viewGroup( + ViewGroupResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { viewGroup(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - private native void addGroup(long chipClusterPtr, AddGroupResponseCallback Callback - , Integer groupId, String groupName - , @Nullable Integer timedInvokeTimeoutMs); - private native void addGroupIfIdentifying(long chipClusterPtr, DefaultClusterCallback Callback - , Integer groupId, String groupName - , @Nullable Integer timedInvokeTimeoutMs); - private native void getGroupMembership(long chipClusterPtr, GetGroupMembershipResponseCallback Callback - , ArrayList groupList - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeAllGroups(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeGroup(long chipClusterPtr, RemoveGroupResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); - private native void viewGroup(long chipClusterPtr, ViewGroupResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addGroup( + long chipClusterPtr, + AddGroupResponseCallback Callback, + Integer groupId, + String groupName, + @Nullable Integer timedInvokeTimeoutMs); + + private native void addGroupIfIdentifying( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer groupId, + String groupName, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getGroupMembership( + long chipClusterPtr, + GetGroupMembershipResponseCallback Callback, + ArrayList groupList, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeAllGroups( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeGroup( + long chipClusterPtr, + RemoveGroupResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void viewGroup( + long chipClusterPtr, + ViewGroupResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + public interface AddGroupResponseCallback { void onSuccess(Integer status, Integer groupId); @@ -6273,69 +6970,61 @@ public interface ViewGroupResponseCallback { void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readNameSupportAttribute( - IntegerAttributeCallback callback - ) { + public void readNameSupportAttribute(IntegerAttributeCallback callback) { readNameSupportAttribute(chipClusterPtr, callback); } + public void subscribeNameSupportAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class IdentifyCluster extends BaseChipCluster { @@ -6348,144 +7037,147 @@ public IdentifyCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void identify(DefaultClusterCallback callback - , Integer identifyTime) { + public void identify(DefaultClusterCallback callback, Integer identifyTime) { identify(chipClusterPtr, callback, identifyTime, null); } - public void identify(DefaultClusterCallback callback - , Integer identifyTime - , int timedInvokeTimeoutMs) { + public void identify( + DefaultClusterCallback callback, Integer identifyTime, int timedInvokeTimeoutMs) { identify(chipClusterPtr, callback, identifyTime, timedInvokeTimeoutMs); } - public void identifyQuery(IdentifyQueryResponseCallback callback - ) { + public void identifyQuery(IdentifyQueryResponseCallback callback) { identifyQuery(chipClusterPtr, callback, null); } - public void identifyQuery(IdentifyQueryResponseCallback callback + public void identifyQuery(IdentifyQueryResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { identifyQuery(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void triggerEffect(DefaultClusterCallback callback - , Integer effectIdentifier, Integer effectVariant) { + public void triggerEffect( + DefaultClusterCallback callback, Integer effectIdentifier, Integer effectVariant) { triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, null); } - public void triggerEffect(DefaultClusterCallback callback - , Integer effectIdentifier, Integer effectVariant - , int timedInvokeTimeoutMs) { - triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); + public void triggerEffect( + DefaultClusterCallback callback, + Integer effectIdentifier, + Integer effectVariant, + int timedInvokeTimeoutMs) { + triggerEffect( + chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); } - private native void identify(long chipClusterPtr, DefaultClusterCallback Callback - , Integer identifyTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void identifyQuery(long chipClusterPtr, IdentifyQueryResponseCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void triggerEffect(long chipClusterPtr, DefaultClusterCallback Callback - , Integer effectIdentifier, Integer effectVariant - , @Nullable Integer timedInvokeTimeoutMs); + private native void identify( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer identifyTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void identifyQuery( + long chipClusterPtr, + IdentifyQueryResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void triggerEffect( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer effectIdentifier, + Integer effectVariant, + @Nullable Integer timedInvokeTimeoutMs); + public interface IdentifyQueryResponseCallback { void onSuccess(Integer timeout); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readIdentifyTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readIdentifyTimeAttribute(IntegerAttributeCallback callback) { readIdentifyTimeAttribute(chipClusterPtr, callback); } + public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value) { writeIdentifyTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeIdentifyTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeIdentifyTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeIdentifyTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeIdentifyTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readIdentifyTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readIdentifyTypeAttribute(IntegerAttributeCallback callback) { readIdentifyTypeAttribute(chipClusterPtr, callback); } + public void subscribeIdentifyTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeIdentifyTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readIdentifyTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeIdentifyTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeIdentifyTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readIdentifyTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeIdentifyTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readIdentifyTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeIdentifyTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeIdentifyTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readIdentifyTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeIdentifyTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class IlluminanceMeasurementCluster extends BaseChipCluster { @@ -6498,164 +7190,165 @@ public IlluminanceMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface MeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface MinMeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface MaxMeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface LightSensorTypeAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute( - MeasuredValueAttributeCallback callback - ) { + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface LightSensorTypeAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(MeasuredValueAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - MeasuredValueAttributeCallback callback - , - int minInterval, int maxInterval) { + MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - MinMeasuredValueAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(MinMeasuredValueAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - MinMeasuredValueAttributeCallback callback - , - int minInterval, int maxInterval) { + MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - MaxMeasuredValueAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(MaxMeasuredValueAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - MaxMeasuredValueAttributeCallback callback - , - int minInterval, int maxInterval) { + MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { + public void readToleranceAttribute(IntegerAttributeCallback callback) { readToleranceAttribute(chipClusterPtr, callback); } + public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLightSensorTypeAttribute( - LightSensorTypeAttributeCallback callback - ) { + public void readLightSensorTypeAttribute(LightSensorTypeAttributeCallback callback) { readLightSensorTypeAttribute(chipClusterPtr, callback); } + public void subscribeLightSensorTypeAttribute( - LightSensorTypeAttributeCallback callback - , - int minInterval, int maxInterval) { + LightSensorTypeAttributeCallback callback, int minInterval, int maxInterval) { subscribeLightSensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - MeasuredValueAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - MeasuredValueAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - MinMeasuredValueAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - MinMeasuredValueAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - MaxMeasuredValueAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - MaxMeasuredValueAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLightSensorTypeAttribute(long chipClusterPtr, - LightSensorTypeAttributeCallback callback - ); - private native void subscribeLightSensorTypeAttribute(long chipClusterPtr, - LightSensorTypeAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, MeasuredValueAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, + MeasuredValueAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, MinMeasuredValueAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, + MinMeasuredValueAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, MaxMeasuredValueAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLightSensorTypeAttribute( + long chipClusterPtr, LightSensorTypeAttributeCallback callback); + + private native void subscribeLightSensorTypeAttribute( + long chipClusterPtr, + LightSensorTypeAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class KeypadInputCluster extends BaseChipCluster { @@ -6668,69 +7361,67 @@ public KeypadInputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void sendKeyRequest(SendKeyResponseCallback callback - , Integer keyCode) { + public void sendKeyRequest(SendKeyResponseCallback callback, Integer keyCode) { sendKeyRequest(chipClusterPtr, callback, keyCode, null); } - public void sendKeyRequest(SendKeyResponseCallback callback - , Integer keyCode - , int timedInvokeTimeoutMs) { + public void sendKeyRequest( + SendKeyResponseCallback callback, Integer keyCode, int timedInvokeTimeoutMs) { sendKeyRequest(chipClusterPtr, callback, keyCode, timedInvokeTimeoutMs); } - private native void sendKeyRequest(long chipClusterPtr, SendKeyResponseCallback Callback - , Integer keyCode - , @Nullable Integer timedInvokeTimeoutMs); + + private native void sendKeyRequest( + long chipClusterPtr, + SendKeyResponseCallback Callback, + Integer keyCode, + @Nullable Integer timedInvokeTimeoutMs); + public interface SendKeyResponseCallback { void onSuccess(Integer status); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 LevelControlCluster extends BaseChipCluster { @@ -6743,617 +7434,726 @@ public LevelControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void move(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride) { + public void move( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionMask, + Integer optionOverride) { move(chipClusterPtr, callback, moveMode, rate, optionMask, optionOverride, null); } - public void move(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - move(chipClusterPtr, callback, moveMode, rate, optionMask, optionOverride, timedInvokeTimeoutMs); + public void move( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + move( + chipClusterPtr, + callback, + moveMode, + rate, + optionMask, + optionOverride, + timedInvokeTimeoutMs); + } + + public void moveToLevel( + DefaultClusterCallback callback, + Integer level, + Integer transitionTime, + Integer optionMask, + Integer optionOverride) { + moveToLevel( + chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, null); + } + + public void moveToLevel( + DefaultClusterCallback callback, + Integer level, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + moveToLevel( + chipClusterPtr, + callback, + level, + transitionTime, + optionMask, + optionOverride, + timedInvokeTimeoutMs); + } + + public void moveToLevelWithOnOff( + DefaultClusterCallback callback, Integer level, Integer transitionTime) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, null); + } + + public void moveToLevelWithOnOff( + DefaultClusterCallback callback, + Integer level, + Integer transitionTime, + int timedInvokeTimeoutMs) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, timedInvokeTimeoutMs); } - public void moveToLevel(DefaultClusterCallback callback - , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride) { - moveToLevel(chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, null); + public void moveWithOnOff(DefaultClusterCallback callback, Integer moveMode, Integer rate) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, null); } - public void moveToLevel(DefaultClusterCallback callback - , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - moveToLevel(chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, timedInvokeTimeoutMs); + public void moveWithOnOff( + DefaultClusterCallback callback, Integer moveMode, Integer rate, int timedInvokeTimeoutMs) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, timedInvokeTimeoutMs); } - public void moveToLevelWithOnOff(DefaultClusterCallback callback - , Integer level, Integer transitionTime) { - moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, null); + public void step( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionMask, + Integer optionOverride) { + step( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionMask, + optionOverride, + null); + } + + public void step( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + step( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionMask, + optionOverride, + timedInvokeTimeoutMs); + } + + public void stepWithOnOff( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime) { + stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, null); } - public void moveToLevelWithOnOff(DefaultClusterCallback callback - , Integer level, Integer transitionTime - , int timedInvokeTimeoutMs) { - moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, timedInvokeTimeoutMs); + public void stepWithOnOff( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + int timedInvokeTimeoutMs) { + stepWithOnOff( + chipClusterPtr, callback, stepMode, stepSize, transitionTime, timedInvokeTimeoutMs); } - public void moveWithOnOff(DefaultClusterCallback callback - , Integer moveMode, Integer rate) { - moveWithOnOff(chipClusterPtr, callback, moveMode, rate, null); + public void stop(DefaultClusterCallback callback, Integer optionMask, Integer optionOverride) { + stop(chipClusterPtr, callback, optionMask, optionOverride, null); } - public void moveWithOnOff(DefaultClusterCallback callback - , Integer moveMode, Integer rate - , int timedInvokeTimeoutMs) { - moveWithOnOff(chipClusterPtr, callback, moveMode, rate, timedInvokeTimeoutMs); + public void stop( + DefaultClusterCallback callback, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + stop(chipClusterPtr, callback, optionMask, optionOverride, timedInvokeTimeoutMs); } - public void step(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride) { - step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionMask, optionOverride, null); + public void stopWithOnOff(DefaultClusterCallback callback) { + stopWithOnOff(chipClusterPtr, callback, null); } - public void step(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionMask, optionOverride, timedInvokeTimeoutMs); + public void stopWithOnOff(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void stepWithOnOff(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime) { - stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, null); + private native void move( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToLevel( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer level, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToLevelWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer level, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + @Nullable Integer timedInvokeTimeoutMs); + + private native void step( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stop( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface OnLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stepWithOnOff(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime - , int timedInvokeTimeoutMs) { - stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, timedInvokeTimeoutMs); + public interface OnTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stop(DefaultClusterCallback callback - , Integer optionMask, Integer optionOverride) { - stop(chipClusterPtr, callback, optionMask, optionOverride, null); + public interface OffTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stop(DefaultClusterCallback callback - , Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - stop(chipClusterPtr, callback, optionMask, optionOverride, timedInvokeTimeoutMs); + public interface DefaultMoveRateAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stopWithOnOff(DefaultClusterCallback callback - ) { - stopWithOnOff(chipClusterPtr, callback, null); + public interface StartUpCurrentLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stopWithOnOff(DefaultClusterCallback callback + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - , int timedInvokeTimeoutMs) { - stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void move(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToLevel(long chipClusterPtr, DefaultClusterCallback Callback - , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToLevelWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer level, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate - , @Nullable Integer timedInvokeTimeoutMs); - private native void step(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void stop(long chipClusterPtr, DefaultClusterCallback Callback - , Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - - public interface OnLevelAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface OnTransitionTimeAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface OffTransitionTimeAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface DefaultMoveRateAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface StartUpCurrentLevelAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readCurrentLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentLevelAttribute(IntegerAttributeCallback callback) { readCurrentLevelAttribute(chipClusterPtr, callback); } + public void subscribeCurrentLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRemainingTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readRemainingTimeAttribute(IntegerAttributeCallback callback) { readRemainingTimeAttribute(chipClusterPtr, callback); } + public void subscribeRemainingTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readMinLevelAttribute(IntegerAttributeCallback callback) { readMinLevelAttribute(chipClusterPtr, callback); } + public void subscribeMinLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxLevelAttribute(IntegerAttributeCallback callback) { readMaxLevelAttribute(chipClusterPtr, callback); } + public void subscribeMaxLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentFrequencyAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentFrequencyAttribute(IntegerAttributeCallback callback) { readCurrentFrequencyAttribute(chipClusterPtr, callback); } + public void subscribeCurrentFrequencyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinFrequencyAttribute( - IntegerAttributeCallback callback - ) { + public void readMinFrequencyAttribute(IntegerAttributeCallback callback) { readMinFrequencyAttribute(chipClusterPtr, callback); } + public void subscribeMinFrequencyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxFrequencyAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxFrequencyAttribute(IntegerAttributeCallback callback) { readMaxFrequencyAttribute(chipClusterPtr, callback); } + public void subscribeMaxFrequencyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOptionsAttribute( - IntegerAttributeCallback callback - ) { + public void readOptionsAttribute(IntegerAttributeCallback callback) { readOptionsAttribute(chipClusterPtr, callback); } + public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value) { writeOptionsAttribute(chipClusterPtr, callback, value, null); } - public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOptionsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOptionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnOffTransitionTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readOnOffTransitionTimeAttribute(IntegerAttributeCallback callback) { readOnOffTransitionTimeAttribute(chipClusterPtr, callback); } + public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnOffTransitionTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnOffTransitionTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnLevelAttribute( - OnLevelAttributeCallback callback - ) { + public void readOnLevelAttribute(OnLevelAttributeCallback callback) { readOnLevelAttribute(chipClusterPtr, callback); } + public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value) { writeOnLevelAttribute(chipClusterPtr, callback, value, null); } - public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnLevelAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnLevelAttribute( - OnLevelAttributeCallback callback - , - int minInterval, int maxInterval) { + OnLevelAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnTransitionTimeAttribute( - OnTransitionTimeAttributeCallback callback - ) { + public void readOnTransitionTimeAttribute(OnTransitionTimeAttributeCallback callback) { readOnTransitionTimeAttribute(chipClusterPtr, callback); } + public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnTransitionTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnTransitionTimeAttribute( - OnTransitionTimeAttributeCallback callback - , - int minInterval, int maxInterval) { + OnTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOffTransitionTimeAttribute( - OffTransitionTimeAttributeCallback callback - ) { + public void readOffTransitionTimeAttribute(OffTransitionTimeAttributeCallback callback) { readOffTransitionTimeAttribute(chipClusterPtr, callback); } + public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOffTransitionTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOffTransitionTimeAttribute( - OffTransitionTimeAttributeCallback callback - , - int minInterval, int maxInterval) { + OffTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) { subscribeOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDefaultMoveRateAttribute( - DefaultMoveRateAttributeCallback callback - ) { + public void readDefaultMoveRateAttribute(DefaultMoveRateAttributeCallback callback) { readDefaultMoveRateAttribute(chipClusterPtr, callback); } + public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value) { writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, null); } - public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeDefaultMoveRateAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeDefaultMoveRateAttribute( - DefaultMoveRateAttributeCallback callback - , - int minInterval, int maxInterval) { + DefaultMoveRateAttributeCallback callback, int minInterval, int maxInterval) { subscribeDefaultMoveRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpCurrentLevelAttribute( - StartUpCurrentLevelAttributeCallback callback - ) { + public void readStartUpCurrentLevelAttribute(StartUpCurrentLevelAttributeCallback callback) { readStartUpCurrentLevelAttribute(chipClusterPtr, callback); } + public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeStartUpCurrentLevelAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeStartUpCurrentLevelAttribute( - StartUpCurrentLevelAttributeCallback callback - , - int minInterval, int maxInterval) { + StartUpCurrentLevelAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartUpCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOnOffTransitionTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOnOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnOffTransitionTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOnLevelAttribute(long chipClusterPtr, - OnLevelAttributeCallback callback - ); - - private native void writeOnLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnLevelAttribute(long chipClusterPtr, - OnLevelAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOnTransitionTimeAttribute(long chipClusterPtr, - OnTransitionTimeAttributeCallback callback - ); - - private native void writeOnTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnTransitionTimeAttribute(long chipClusterPtr, - OnTransitionTimeAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOffTransitionTimeAttribute(long chipClusterPtr, - OffTransitionTimeAttributeCallback callback - ); - - private native void writeOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOffTransitionTimeAttribute(long chipClusterPtr, - OffTransitionTimeAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readDefaultMoveRateAttribute(long chipClusterPtr, - DefaultMoveRateAttributeCallback callback - ); - - private native void writeDefaultMoveRateAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeDefaultMoveRateAttribute(long chipClusterPtr, - DefaultMoveRateAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readStartUpCurrentLevelAttribute(long chipClusterPtr, - StartUpCurrentLevelAttributeCallback callback - ); - - private native void writeStartUpCurrentLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeStartUpCurrentLevelAttribute(long chipClusterPtr, - StartUpCurrentLevelAttributeCallback 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); - } + private native void readCurrentLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public static class LocalizationConfigurationCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 43L; + private native void subscribeCurrentLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public LocalizationConfigurationCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void readRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - @Override - public native long initWithDevice(long devicePtr, int endpointId); + private native void subscribeRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public interface SupportedLocalesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void readMinLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readActiveLocaleAttribute( - CharStringAttributeCallback callback - ) { - readActiveLocaleAttribute(chipClusterPtr, callback); - } - public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value) { - writeActiveLocaleAttribute(chipClusterPtr, callback, value, null); + private native void subscribeMinLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOptionsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnOffTransitionTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOnOffTransitionTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnOffTransitionTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnLevelAttribute( + long chipClusterPtr, OnLevelAttributeCallback callback); + + private native void writeOnLevelAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnLevelAttribute( + long chipClusterPtr, OnLevelAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnTransitionTimeAttribute( + long chipClusterPtr, OnTransitionTimeAttributeCallback callback); + + private native void writeOnTransitionTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnTransitionTimeAttribute( + long chipClusterPtr, + OnTransitionTimeAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOffTransitionTimeAttribute( + long chipClusterPtr, OffTransitionTimeAttributeCallback callback); + + private native void writeOffTransitionTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOffTransitionTimeAttribute( + long chipClusterPtr, + OffTransitionTimeAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readDefaultMoveRateAttribute( + long chipClusterPtr, DefaultMoveRateAttributeCallback callback); + + private native void writeDefaultMoveRateAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeDefaultMoveRateAttribute( + long chipClusterPtr, + DefaultMoveRateAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readStartUpCurrentLevelAttribute( + long chipClusterPtr, StartUpCurrentLevelAttributeCallback callback); + + private native void writeStartUpCurrentLevelAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeStartUpCurrentLevelAttribute( + long chipClusterPtr, + StartUpCurrentLevelAttributeCallback 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 LocalizationConfigurationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 43L; + + public LocalizationConfigurationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface SupportedLocalesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void readActiveLocaleAttribute(CharStringAttributeCallback callback) { + readActiveLocaleAttribute(chipClusterPtr, callback); + } + + public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value) { + writeActiveLocaleAttribute(chipClusterPtr, callback, value, null); + } + + public void writeActiveLocaleAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeActiveLocaleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeActiveLocaleAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveLocaleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedLocalesAttribute( - SupportedLocalesAttributeCallback callback - ) { + public void readSupportedLocalesAttribute(SupportedLocalesAttributeCallback callback) { readSupportedLocalesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedLocalesAttribute( - SupportedLocalesAttributeCallback callback - , - int minInterval, int maxInterval) { + SupportedLocalesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedLocalesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readActiveLocaleAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeActiveLocaleAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeActiveLocaleAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedLocalesAttribute(long chipClusterPtr, - SupportedLocalesAttributeCallback callback - ); - private native void subscribeSupportedLocalesAttribute(long chipClusterPtr, - SupportedLocalesAttributeCallback 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); + private native void readActiveLocaleAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeActiveLocaleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeActiveLocaleAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSupportedLocalesAttribute( + long chipClusterPtr, SupportedLocalesAttributeCallback callback); + + private native void subscribeSupportedLocalesAttribute( + long chipClusterPtr, + SupportedLocalesAttributeCallback 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 LowPowerCluster extends BaseChipCluster { @@ -7366,63 +8166,60 @@ public LowPowerCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void sleep(DefaultClusterCallback callback - ) { + public void sleep(DefaultClusterCallback callback) { sleep(chipClusterPtr, callback, null); } - public void sleep(DefaultClusterCallback callback + public void sleep(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { sleep(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void sleep(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void sleep( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - private native void readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class MediaInputCluster extends BaseChipCluster { @@ -7435,148 +8232,146 @@ public MediaInputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void hideInputStatusRequest(DefaultClusterCallback callback - ) { + public void hideInputStatusRequest(DefaultClusterCallback callback) { hideInputStatusRequest(chipClusterPtr, callback, null); } - public void hideInputStatusRequest(DefaultClusterCallback callback + public void hideInputStatusRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { hideInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void renameInputRequest(DefaultClusterCallback callback - , Integer index, String name) { + public void renameInputRequest(DefaultClusterCallback callback, Integer index, String name) { renameInputRequest(chipClusterPtr, callback, index, name, null); } - public void renameInputRequest(DefaultClusterCallback callback - , Integer index, String name - , int timedInvokeTimeoutMs) { + public void renameInputRequest( + DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) { renameInputRequest(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); } - public void selectInputRequest(DefaultClusterCallback callback - , Integer index) { + public void selectInputRequest(DefaultClusterCallback callback, Integer index) { selectInputRequest(chipClusterPtr, callback, index, null); } - public void selectInputRequest(DefaultClusterCallback callback - , Integer index - , int timedInvokeTimeoutMs) { + public void selectInputRequest( + DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) { selectInputRequest(chipClusterPtr, callback, index, timedInvokeTimeoutMs); } - public void showInputStatusRequest(DefaultClusterCallback callback - ) { + public void showInputStatusRequest(DefaultClusterCallback callback) { showInputStatusRequest(chipClusterPtr, callback, null); } - public void showInputStatusRequest(DefaultClusterCallback callback + public void showInputStatusRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { showInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void hideInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void renameInputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index, String name - , @Nullable Integer timedInvokeTimeoutMs); - private native void selectInputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index - , @Nullable Integer timedInvokeTimeoutMs); - private native void showInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback + private native void hideInputStatusRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); + private native void renameInputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + String name, + @Nullable Integer timedInvokeTimeoutMs); - public interface MediaInputListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void selectInputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + @Nullable Integer timedInvokeTimeoutMs); + + private native void showInputStatusRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface MediaInputListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readMediaInputListAttribute( - MediaInputListAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMediaInputListAttribute(MediaInputListAttributeCallback callback) { readMediaInputListAttribute(chipClusterPtr, callback); } + public void subscribeMediaInputListAttribute( - MediaInputListAttributeCallback callback - , - int minInterval, int maxInterval) { + MediaInputListAttributeCallback callback, int minInterval, int maxInterval) { subscribeMediaInputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentMediaInputAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentMediaInputAttribute(IntegerAttributeCallback callback) { readCurrentMediaInputAttribute(chipClusterPtr, callback); } + public void subscribeCurrentMediaInputAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentMediaInputAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMediaInputListAttribute(long chipClusterPtr, - MediaInputListAttributeCallback callback - ); - private native void subscribeMediaInputListAttribute(long chipClusterPtr, - MediaInputListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentMediaInputAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentMediaInputAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMediaInputListAttribute( + long chipClusterPtr, MediaInputListAttributeCallback callback); + + private native void subscribeMediaInputListAttribute( + long chipClusterPtr, + MediaInputListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentMediaInputAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentMediaInputAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class MediaPlaybackCluster extends BaseChipCluster { @@ -7589,323 +8384,304 @@ public MediaPlaybackCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void fastForwardRequest(PlaybackResponseCallback callback - ) { + public void fastForwardRequest(PlaybackResponseCallback callback) { fastForwardRequest(chipClusterPtr, callback, null); } - public void fastForwardRequest(PlaybackResponseCallback callback + public void fastForwardRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { fastForwardRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void nextRequest(PlaybackResponseCallback callback - ) { + public void nextRequest(PlaybackResponseCallback callback) { nextRequest(chipClusterPtr, callback, null); } - public void nextRequest(PlaybackResponseCallback callback + public void nextRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { nextRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void pauseRequest(PlaybackResponseCallback callback - ) { + public void pauseRequest(PlaybackResponseCallback callback) { pauseRequest(chipClusterPtr, callback, null); } - public void pauseRequest(PlaybackResponseCallback callback + public void pauseRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { pauseRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void playRequest(PlaybackResponseCallback callback - ) { + public void playRequest(PlaybackResponseCallback callback) { playRequest(chipClusterPtr, callback, null); } - public void playRequest(PlaybackResponseCallback callback + public void playRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { playRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void previousRequest(PlaybackResponseCallback callback - ) { + public void previousRequest(PlaybackResponseCallback callback) { previousRequest(chipClusterPtr, callback, null); } - public void previousRequest(PlaybackResponseCallback callback + public void previousRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { previousRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void rewindRequest(PlaybackResponseCallback callback - ) { + public void rewindRequest(PlaybackResponseCallback callback) { rewindRequest(chipClusterPtr, callback, null); } - public void rewindRequest(PlaybackResponseCallback callback + public void rewindRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { rewindRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void seekRequest(PlaybackResponseCallback callback - , Long position) { + public void seekRequest(PlaybackResponseCallback callback, Long position) { seekRequest(chipClusterPtr, callback, position, null); } - public void seekRequest(PlaybackResponseCallback callback - , Long position - , int timedInvokeTimeoutMs) { + public void seekRequest( + PlaybackResponseCallback callback, Long position, int timedInvokeTimeoutMs) { seekRequest(chipClusterPtr, callback, position, timedInvokeTimeoutMs); } - public void skipBackwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds) { + public void skipBackwardRequest( + PlaybackResponseCallback callback, Long deltaPositionMilliseconds) { skipBackwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, null); } - public void skipBackwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds - , int timedInvokeTimeoutMs) { - skipBackwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); + public void skipBackwardRequest( + PlaybackResponseCallback callback, + Long deltaPositionMilliseconds, + int timedInvokeTimeoutMs) { + skipBackwardRequest( + chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); } - public void skipForwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds) { + public void skipForwardRequest( + PlaybackResponseCallback callback, Long deltaPositionMilliseconds) { skipForwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, null); } - public void skipForwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds - , int timedInvokeTimeoutMs) { + public void skipForwardRequest( + PlaybackResponseCallback callback, + Long deltaPositionMilliseconds, + int timedInvokeTimeoutMs) { skipForwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); } - public void startOverRequest(PlaybackResponseCallback callback - ) { + public void startOverRequest(PlaybackResponseCallback callback) { startOverRequest(chipClusterPtr, callback, null); } - public void startOverRequest(PlaybackResponseCallback callback + public void startOverRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { startOverRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void stopRequest(PlaybackResponseCallback callback - ) { + public void stopRequest(PlaybackResponseCallback callback) { stopRequest(chipClusterPtr, callback, null); } - public void stopRequest(PlaybackResponseCallback callback + public void stopRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { stopRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void fastForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void nextRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void pauseRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void playRequest(long chipClusterPtr, PlaybackResponseCallback Callback + private native void fastForwardRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void nextRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void pauseRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void playRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void previousRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void rewindRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void seekRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + Long position, + @Nullable Integer timedInvokeTimeoutMs); + + private native void skipBackwardRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + Long deltaPositionMilliseconds, + @Nullable Integer timedInvokeTimeoutMs); + + private native void skipForwardRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + Long deltaPositionMilliseconds, + @Nullable Integer timedInvokeTimeoutMs); + + private native void startOverRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void previousRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void rewindRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void seekRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , Long position - , @Nullable Integer timedInvokeTimeoutMs); - private native void skipBackwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , Long deltaPositionMilliseconds - , @Nullable Integer timedInvokeTimeoutMs); - private native void skipForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , Long deltaPositionMilliseconds - , @Nullable Integer timedInvokeTimeoutMs); - private native void startOverRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); public interface PlaybackResponseCallback { void onSuccess(Integer status); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readPlaybackStateAttribute( - IntegerAttributeCallback callback - ) { + public void readPlaybackStateAttribute(IntegerAttributeCallback callback) { readPlaybackStateAttribute(chipClusterPtr, callback); } + public void subscribePlaybackStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePlaybackStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartTimeAttribute( - LongAttributeCallback callback - ) { + public void readStartTimeAttribute(LongAttributeCallback callback) { readStartTimeAttribute(chipClusterPtr, callback); } + public void subscribeStartTimeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDurationAttribute( - LongAttributeCallback callback - ) { + public void readDurationAttribute(LongAttributeCallback callback) { readDurationAttribute(chipClusterPtr, callback); } + public void subscribeDurationAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPlaybackSpeedAttribute( - FloatAttributeCallback callback - ) { + public void readPlaybackSpeedAttribute(FloatAttributeCallback callback) { readPlaybackSpeedAttribute(chipClusterPtr, callback); } + public void subscribePlaybackSpeedAttribute( - FloatAttributeCallback callback -, - int minInterval, int maxInterval) { + FloatAttributeCallback callback, int minInterval, int maxInterval) { subscribePlaybackSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSeekRangeEndAttribute( - LongAttributeCallback callback - ) { + public void readSeekRangeEndAttribute(LongAttributeCallback callback) { readSeekRangeEndAttribute(chipClusterPtr, callback); } + public void subscribeSeekRangeEndAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeSeekRangeEndAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSeekRangeStartAttribute( - LongAttributeCallback callback - ) { + public void readSeekRangeStartAttribute(LongAttributeCallback callback) { readSeekRangeStartAttribute(chipClusterPtr, callback); } + public void subscribeSeekRangeStartAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeSeekRangeStartAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readPlaybackStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePlaybackStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeStartTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDurationAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeDurationAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPlaybackSpeedAttribute(long chipClusterPtr, - FloatAttributeCallback callback - ); - private native void subscribePlaybackSpeedAttribute(long chipClusterPtr, - FloatAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSeekRangeEndAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeSeekRangeEndAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSeekRangeStartAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeSeekRangeStartAttribute(long chipClusterPtr, - LongAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readPlaybackStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePlaybackStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartTimeAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeStartTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDurationAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeDurationAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPlaybackSpeedAttribute( + long chipClusterPtr, FloatAttributeCallback callback); + + private native void subscribePlaybackSpeedAttribute( + long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSeekRangeEndAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeSeekRangeEndAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSeekRangeStartAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeSeekRangeStartAttribute( + long chipClusterPtr, LongAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ModeSelectCluster extends BaseChipCluster { @@ -7918,172 +8694,164 @@ public ModeSelectCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void changeToMode(DefaultClusterCallback callback - , Integer newMode) { + public void changeToMode(DefaultClusterCallback callback, Integer newMode) { changeToMode(chipClusterPtr, callback, newMode, null); } - public void changeToMode(DefaultClusterCallback callback - , Integer newMode - , int timedInvokeTimeoutMs) { + public void changeToMode( + DefaultClusterCallback callback, Integer newMode, int timedInvokeTimeoutMs) { changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs); } - private native void changeToMode(long chipClusterPtr, DefaultClusterCallback Callback - , Integer newMode - , @Nullable Integer timedInvokeTimeoutMs); - public interface SupportedModesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void changeToMode( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer newMode, + @Nullable Integer timedInvokeTimeoutMs); + + public interface SupportedModesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readCurrentModeAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentModeAttribute(IntegerAttributeCallback callback) { readCurrentModeAttribute(chipClusterPtr, callback); } + public void subscribeCurrentModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedModesAttribute( - SupportedModesAttributeCallback callback - ) { + public void readSupportedModesAttribute(SupportedModesAttributeCallback callback) { readSupportedModesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedModesAttribute( - SupportedModesAttributeCallback callback - , - int minInterval, int maxInterval) { + SupportedModesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnModeAttribute( - IntegerAttributeCallback callback - ) { + public void readOnModeAttribute(IntegerAttributeCallback callback) { readOnModeAttribute(chipClusterPtr, callback); } + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) { writeOnModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpModeAttribute( - IntegerAttributeCallback callback - ) { + public void readStartUpModeAttribute(IntegerAttributeCallback callback) { readStartUpModeAttribute(chipClusterPtr, callback); } + public void subscribeStartUpModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDescriptionAttribute( - CharStringAttributeCallback callback - ) { + public void readDescriptionAttribute(CharStringAttributeCallback callback) { readDescriptionAttribute(chipClusterPtr, callback); } + public void subscribeDescriptionAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedModesAttribute(long chipClusterPtr, - SupportedModesAttributeCallback callback - ); - private native void subscribeSupportedModesAttribute(long chipClusterPtr, - SupportedModesAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOnModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartUpModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStartUpModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readCurrentModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSupportedModesAttribute( + long chipClusterPtr, SupportedModesAttributeCallback callback); + + private native void subscribeSupportedModesAttribute( + long chipClusterPtr, + SupportedModesAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOnModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOnModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartUpModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStartUpModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDescriptionAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeDescriptionAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class NetworkCommissioningCluster extends BaseChipCluster { @@ -8096,89 +8864,135 @@ public NetworkCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback - , byte[] operationalDataset, Long breadcrumb) { + public void addOrUpdateThreadNetwork( + NetworkConfigResponseCallback callback, byte[] operationalDataset, Long breadcrumb) { addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, null); } - public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback - , byte[] operationalDataset, Long breadcrumb - , int timedInvokeTimeoutMs) { - addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs); + public void addOrUpdateThreadNetwork( + NetworkConfigResponseCallback callback, + byte[] operationalDataset, + Long breadcrumb, + int timedInvokeTimeoutMs) { + addOrUpdateThreadNetwork( + chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs); } - public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback - , byte[] ssid, byte[] credentials, Long breadcrumb) { + public void addOrUpdateWiFiNetwork( + NetworkConfigResponseCallback callback, byte[] ssid, byte[] credentials, Long breadcrumb) { addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, null); } - public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback - , byte[] ssid, byte[] credentials, Long breadcrumb - , int timedInvokeTimeoutMs) { - addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs); + public void addOrUpdateWiFiNetwork( + NetworkConfigResponseCallback callback, + byte[] ssid, + byte[] credentials, + Long breadcrumb, + int timedInvokeTimeoutMs) { + addOrUpdateWiFiNetwork( + chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs); } - public void connectNetwork(ConnectNetworkResponseCallback callback - , byte[] networkID, Long breadcrumb) { + public void connectNetwork( + ConnectNetworkResponseCallback callback, byte[] networkID, Long breadcrumb) { connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); } - public void connectNetwork(ConnectNetworkResponseCallback callback - , byte[] networkID, Long breadcrumb - , int timedInvokeTimeoutMs) { + public void connectNetwork( + ConnectNetworkResponseCallback callback, + byte[] networkID, + Long breadcrumb, + int timedInvokeTimeoutMs) { connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); } - public void removeNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Long breadcrumb) { + public void removeNetwork( + NetworkConfigResponseCallback callback, byte[] networkID, Long breadcrumb) { removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); } - public void removeNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Long breadcrumb - , int timedInvokeTimeoutMs) { + public void removeNetwork( + NetworkConfigResponseCallback callback, + byte[] networkID, + Long breadcrumb, + int timedInvokeTimeoutMs) { removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); } - public void reorderNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Integer networkIndex, Long breadcrumb) { + public void reorderNetwork( + NetworkConfigResponseCallback callback, + byte[] networkID, + Integer networkIndex, + Long breadcrumb) { reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, null); } - public void reorderNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Integer networkIndex, Long breadcrumb - , int timedInvokeTimeoutMs) { - reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs); + public void reorderNetwork( + NetworkConfigResponseCallback callback, + byte[] networkID, + Integer networkIndex, + Long breadcrumb, + int timedInvokeTimeoutMs) { + reorderNetwork( + chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs); } - public void scanNetworks(ScanNetworksResponseCallback callback - , byte[] ssid, Long breadcrumb) { + public void scanNetworks(ScanNetworksResponseCallback callback, byte[] ssid, Long breadcrumb) { scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, null); } - public void scanNetworks(ScanNetworksResponseCallback callback - , byte[] ssid, Long breadcrumb - , int timedInvokeTimeoutMs) { + public void scanNetworks( + ScanNetworksResponseCallback callback, + byte[] ssid, + Long breadcrumb, + int timedInvokeTimeoutMs) { scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, timedInvokeTimeoutMs); } - private native void addOrUpdateThreadNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] operationalDataset, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void addOrUpdateWiFiNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] ssid, byte[] credentials, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void connectNetwork(long chipClusterPtr, ConnectNetworkResponseCallback Callback - , byte[] networkID, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] networkID, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void reorderNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] networkID, Integer networkIndex, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void scanNetworks(long chipClusterPtr, ScanNetworksResponseCallback Callback - , byte[] ssid, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addOrUpdateThreadNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] operationalDataset, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void addOrUpdateWiFiNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] ssid, + byte[] credentials, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void connectNetwork( + long chipClusterPtr, + ConnectNetworkResponseCallback Callback, + byte[] networkID, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] networkID, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void reorderNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] networkID, + Integer networkIndex, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void scanNetworks( + long chipClusterPtr, + ScanNetworksResponseCallback Callback, + byte[] ssid, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + public interface ConnectNetworkResponseCallback { void onSuccess(Integer networkingStatus, String debugText, Long errorValue); @@ -8192,216 +9006,192 @@ public interface NetworkConfigResponseCallback { } public interface ScanNetworksResponseCallback { - void onSuccess(Integer networkingStatus, String debugText, Optional> wiFiScanResults, Optional> threadScanResults); + void onSuccess( + Integer networkingStatus, + String debugText, + Optional> + wiFiScanResults, + Optional> + threadScanResults); void onError(Exception error); } + public interface NetworksAttributeCallback { + void onSuccess(List valueList); - public interface NetworksAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readMaxNetworksAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxNetworksAttribute(IntegerAttributeCallback callback) { readMaxNetworksAttribute(chipClusterPtr, callback); } + public void subscribeMaxNetworksAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNetworksAttribute( - NetworksAttributeCallback callback - ) { + public void readNetworksAttribute(NetworksAttributeCallback callback) { readNetworksAttribute(chipClusterPtr, callback); } + public void subscribeNetworksAttribute( - NetworksAttributeCallback callback - , - int minInterval, int maxInterval) { + NetworksAttributeCallback callback, int minInterval, int maxInterval) { subscribeNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readScanMaxTimeSecondsAttribute( - IntegerAttributeCallback callback - ) { + public void readScanMaxTimeSecondsAttribute(IntegerAttributeCallback callback) { readScanMaxTimeSecondsAttribute(chipClusterPtr, callback); } + public void subscribeScanMaxTimeSecondsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeScanMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readConnectMaxTimeSecondsAttribute( - IntegerAttributeCallback callback - ) { + public void readConnectMaxTimeSecondsAttribute(IntegerAttributeCallback callback) { readConnectMaxTimeSecondsAttribute(chipClusterPtr, callback); } + public void subscribeConnectMaxTimeSecondsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeConnectMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInterfaceEnabledAttribute( - BooleanAttributeCallback callback - ) { + public void readInterfaceEnabledAttribute(BooleanAttributeCallback callback) { readInterfaceEnabledAttribute(chipClusterPtr, callback); } + public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value) { writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, null); } - public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeInterfaceEnabledAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInterfaceEnabledAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeInterfaceEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastNetworkingStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readLastNetworkingStatusAttribute(IntegerAttributeCallback callback) { readLastNetworkingStatusAttribute(chipClusterPtr, callback); } + public void subscribeLastNetworkingStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLastNetworkingStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastNetworkIDAttribute( - OctetStringAttributeCallback callback - ) { + public void readLastNetworkIDAttribute(OctetStringAttributeCallback callback) { readLastNetworkIDAttribute(chipClusterPtr, callback); } + public void subscribeLastNetworkIDAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLastNetworkIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastConnectErrorValueAttribute( - LongAttributeCallback callback - ) { + public void readLastConnectErrorValueAttribute(LongAttributeCallback callback) { readLastConnectErrorValueAttribute(chipClusterPtr, callback); } + public void subscribeLastConnectErrorValueAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeLastConnectErrorValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMaxNetworksAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxNetworksAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNetworksAttribute(long chipClusterPtr, - NetworksAttributeCallback callback - ); - private native void subscribeNetworksAttribute(long chipClusterPtr, - NetworksAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readScanMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeScanMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readConnectMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeConnectMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInterfaceEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeInterfaceEnabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInterfaceEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLastNetworkingStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLastNetworkingStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLastNetworkIDAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeLastNetworkIDAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLastConnectErrorValueAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeLastConnectErrorValueAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readMaxNetworksAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxNetworksAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNetworksAttribute( + long chipClusterPtr, NetworksAttributeCallback callback); + + private native void subscribeNetworksAttribute( + long chipClusterPtr, NetworksAttributeCallback callback, int minInterval, int maxInterval); + + private native void readScanMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeScanMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readConnectMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeConnectMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInterfaceEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeInterfaceEnabledAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInterfaceEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLastNetworkingStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLastNetworkingStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLastNetworkIDAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeLastNetworkIDAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLastConnectErrorValueAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeLastConnectErrorValueAttribute( + long chipClusterPtr, LongAttributeCallback 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 OtaSoftwareUpdateProviderCluster extends BaseChipCluster { @@ -8414,47 +9204,109 @@ public OtaSoftwareUpdateProviderCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void applyUpdateRequest(ApplyUpdateResponseCallback callback - , byte[] updateToken, Long newVersion) { + public void applyUpdateRequest( + ApplyUpdateResponseCallback callback, byte[] updateToken, Long newVersion) { applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, null); } - public void applyUpdateRequest(ApplyUpdateResponseCallback callback - , byte[] updateToken, Long newVersion - , int timedInvokeTimeoutMs) { + public void applyUpdateRequest( + ApplyUpdateResponseCallback callback, + byte[] updateToken, + Long newVersion, + int timedInvokeTimeoutMs) { applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, timedInvokeTimeoutMs); } - public void notifyUpdateApplied(DefaultClusterCallback callback - , byte[] updateToken, Long softwareVersion) { + public void notifyUpdateApplied( + DefaultClusterCallback callback, byte[] updateToken, Long softwareVersion) { notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, null); } - public void notifyUpdateApplied(DefaultClusterCallback callback - , byte[] updateToken, Long softwareVersion - , int timedInvokeTimeoutMs) { - notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs); - } - - public void queryImage(QueryImageResponseCallback callback - , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider) { - queryImage(chipClusterPtr, callback, vendorId, productId, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, null); - } + public void notifyUpdateApplied( + DefaultClusterCallback callback, + byte[] updateToken, + Long softwareVersion, + int timedInvokeTimeoutMs) { + notifyUpdateApplied( + chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs); + } + + public void queryImage( + QueryImageResponseCallback callback, + Integer vendorId, + Integer productId, + Long softwareVersion, + ArrayList protocolsSupported, + Optional hardwareVersion, + Optional location, + Optional requestorCanConsent, + Optional metadataForProvider) { + queryImage( + chipClusterPtr, + callback, + vendorId, + productId, + softwareVersion, + protocolsSupported, + hardwareVersion, + location, + requestorCanConsent, + metadataForProvider, + null); + } + + public void queryImage( + QueryImageResponseCallback callback, + Integer vendorId, + Integer productId, + Long softwareVersion, + ArrayList protocolsSupported, + Optional hardwareVersion, + Optional location, + Optional requestorCanConsent, + Optional metadataForProvider, + int timedInvokeTimeoutMs) { + queryImage( + chipClusterPtr, + callback, + vendorId, + productId, + softwareVersion, + protocolsSupported, + hardwareVersion, + location, + requestorCanConsent, + metadataForProvider, + timedInvokeTimeoutMs); + } + + private native void applyUpdateRequest( + long chipClusterPtr, + ApplyUpdateResponseCallback Callback, + byte[] updateToken, + Long newVersion, + @Nullable Integer timedInvokeTimeoutMs); + + private native void notifyUpdateApplied( + long chipClusterPtr, + DefaultClusterCallback Callback, + byte[] updateToken, + Long softwareVersion, + @Nullable Integer timedInvokeTimeoutMs); + + private native void queryImage( + long chipClusterPtr, + QueryImageResponseCallback Callback, + Integer vendorId, + Integer productId, + Long softwareVersion, + ArrayList protocolsSupported, + Optional hardwareVersion, + Optional location, + Optional requestorCanConsent, + Optional metadataForProvider, + @Nullable Integer timedInvokeTimeoutMs); - public void queryImage(QueryImageResponseCallback callback - , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider - , int timedInvokeTimeoutMs) { - queryImage(chipClusterPtr, callback, vendorId, productId, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, timedInvokeTimeoutMs); - } - private native void applyUpdateRequest(long chipClusterPtr, ApplyUpdateResponseCallback Callback - , byte[] updateToken, Long newVersion - , @Nullable Integer timedInvokeTimeoutMs); - private native void notifyUpdateApplied(long chipClusterPtr, DefaultClusterCallback Callback - , byte[] updateToken, Long softwareVersion - , @Nullable Integer timedInvokeTimeoutMs); - private native void queryImage(long chipClusterPtr, QueryImageResponseCallback Callback - , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider - , @Nullable Integer timedInvokeTimeoutMs); public interface ApplyUpdateResponseCallback { void onSuccess(Integer action, Long delayedActionTime); @@ -8462,55 +9314,59 @@ public interface ApplyUpdateResponseCallback { } public interface QueryImageResponseCallback { - void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor); + void onSuccess( + Integer status, + Optional delayedActionTime, + Optional imageURI, + Optional softwareVersion, + Optional softwareVersionString, + Optional updateToken, + Optional userConsentNeeded, + Optional metadataForRequestor); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 OtaSoftwareUpdateRequestorCluster extends BaseChipCluster { @@ -8523,158 +9379,194 @@ public OtaSoftwareUpdateRequestorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void announceOtaProvider(DefaultClusterCallback callback - , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint) { - announceOtaProvider(chipClusterPtr, callback, providerNodeId, vendorId, announcementReason, metadataForNode, endpoint, null); + public void announceOtaProvider( + DefaultClusterCallback callback, + Long providerNodeId, + Integer vendorId, + Integer announcementReason, + Optional metadataForNode, + Integer endpoint) { + announceOtaProvider( + chipClusterPtr, + callback, + providerNodeId, + vendorId, + announcementReason, + metadataForNode, + endpoint, + null); } - public void announceOtaProvider(DefaultClusterCallback callback - , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint - , int timedInvokeTimeoutMs) { - announceOtaProvider(chipClusterPtr, callback, providerNodeId, vendorId, announcementReason, metadataForNode, endpoint, timedInvokeTimeoutMs); + public void announceOtaProvider( + DefaultClusterCallback callback, + Long providerNodeId, + Integer vendorId, + Integer announcementReason, + Optional metadataForNode, + Integer endpoint, + int timedInvokeTimeoutMs) { + announceOtaProvider( + chipClusterPtr, + callback, + providerNodeId, + vendorId, + announcementReason, + metadataForNode, + endpoint, + timedInvokeTimeoutMs); } - private native void announceOtaProvider(long chipClusterPtr, DefaultClusterCallback Callback - , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint - , @Nullable Integer timedInvokeTimeoutMs); - public interface DefaultOtaProvidersAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface UpdateStateProgressAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void announceOtaProvider( + long chipClusterPtr, + DefaultClusterCallback Callback, + Long providerNodeId, + Integer vendorId, + Integer announcementReason, + Optional metadataForNode, + Integer endpoint, + @Nullable Integer timedInvokeTimeoutMs); + + public interface DefaultOtaProvidersAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface UpdateStateProgressAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readDefaultOtaProvidersAttribute( - DefaultOtaProvidersAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readDefaultOtaProvidersAttribute(DefaultOtaProvidersAttributeCallback callback) { readDefaultOtaProvidersAttribute(chipClusterPtr, callback); } - public void writeDefaultOtaProvidersAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeDefaultOtaProvidersAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeDefaultOtaProvidersAttribute(chipClusterPtr, callback, value, null); } - public void writeDefaultOtaProvidersAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeDefaultOtaProvidersAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeDefaultOtaProvidersAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeDefaultOtaProvidersAttribute( - DefaultOtaProvidersAttributeCallback callback - , - int minInterval, int maxInterval) { + DefaultOtaProvidersAttributeCallback callback, int minInterval, int maxInterval) { subscribeDefaultOtaProvidersAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdatePossibleAttribute( - BooleanAttributeCallback callback - ) { + public void readUpdatePossibleAttribute(BooleanAttributeCallback callback) { readUpdatePossibleAttribute(chipClusterPtr, callback); } + public void subscribeUpdatePossibleAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpdatePossibleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdateStateAttribute( - IntegerAttributeCallback callback - ) { + public void readUpdateStateAttribute(IntegerAttributeCallback callback) { readUpdateStateAttribute(chipClusterPtr, callback); } + public void subscribeUpdateStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpdateStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdateStateProgressAttribute( - UpdateStateProgressAttributeCallback callback - ) { + public void readUpdateStateProgressAttribute(UpdateStateProgressAttributeCallback callback) { readUpdateStateProgressAttribute(chipClusterPtr, callback); } + public void subscribeUpdateStateProgressAttribute( - UpdateStateProgressAttributeCallback callback - , - int minInterval, int maxInterval) { + UpdateStateProgressAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpdateStateProgressAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readDefaultOtaProvidersAttribute(long chipClusterPtr, - DefaultOtaProvidersAttributeCallback callback - ); - - private native void writeDefaultOtaProvidersAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeDefaultOtaProvidersAttribute(long chipClusterPtr, - DefaultOtaProvidersAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readUpdatePossibleAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeUpdatePossibleAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUpdateStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeUpdateStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUpdateStateProgressAttribute(long chipClusterPtr, - UpdateStateProgressAttributeCallback callback - ); - private native void subscribeUpdateStateProgressAttribute(long chipClusterPtr, - UpdateStateProgressAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readDefaultOtaProvidersAttribute( + long chipClusterPtr, DefaultOtaProvidersAttributeCallback callback); + + private native void writeDefaultOtaProvidersAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeDefaultOtaProvidersAttribute( + long chipClusterPtr, + DefaultOtaProvidersAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readUpdatePossibleAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeUpdatePossibleAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUpdateStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeUpdateStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUpdateStateProgressAttribute( + long chipClusterPtr, UpdateStateProgressAttributeCallback callback); + + private native void subscribeUpdateStateProgressAttribute( + long chipClusterPtr, + UpdateStateProgressAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class OccupancySensingCluster extends BaseChipCluster { @@ -8687,106 +9579,92 @@ public OccupancySensingCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readOccupancyAttribute( - IntegerAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readOccupancyAttribute(IntegerAttributeCallback callback) { readOccupancyAttribute(chipClusterPtr, callback); } + public void subscribeOccupancyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupancyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupancySensorTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupancySensorTypeAttribute(IntegerAttributeCallback callback) { readOccupancySensorTypeAttribute(chipClusterPtr, callback); } + public void subscribeOccupancySensorTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupancySensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupancySensorTypeBitmapAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupancySensorTypeBitmapAttribute(IntegerAttributeCallback callback) { readOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback); } + public void subscribeOccupancySensorTypeBitmapAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeOccupancySensorTypeBitmapAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOccupancyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOccupancyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupancySensorTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOccupancySensorTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupancySensorTypeBitmapAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOccupancySensorTypeBitmapAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readOccupancyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOccupancyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOccupancySensorTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeBitmapAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOccupancySensorTypeBitmapAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class OnOffCluster extends BaseChipCluster { @@ -8799,274 +9677,281 @@ public OnOffCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void off(DefaultClusterCallback callback - ) { + public void off(DefaultClusterCallback callback) { off(chipClusterPtr, callback, null); } - public void off(DefaultClusterCallback callback + public void off(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { off(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void offWithEffect(DefaultClusterCallback callback - , Integer effectId, Integer effectVariant) { + public void offWithEffect( + DefaultClusterCallback callback, Integer effectId, Integer effectVariant) { offWithEffect(chipClusterPtr, callback, effectId, effectVariant, null); } - public void offWithEffect(DefaultClusterCallback callback - , Integer effectId, Integer effectVariant - , int timedInvokeTimeoutMs) { + public void offWithEffect( + DefaultClusterCallback callback, + Integer effectId, + Integer effectVariant, + int timedInvokeTimeoutMs) { offWithEffect(chipClusterPtr, callback, effectId, effectVariant, timedInvokeTimeoutMs); } - public void on(DefaultClusterCallback callback - ) { + public void on(DefaultClusterCallback callback) { on(chipClusterPtr, callback, null); } - public void on(DefaultClusterCallback callback + public void on(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { on(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void onWithRecallGlobalScene(DefaultClusterCallback callback - ) { + public void onWithRecallGlobalScene(DefaultClusterCallback callback) { onWithRecallGlobalScene(chipClusterPtr, callback, null); } - public void onWithRecallGlobalScene(DefaultClusterCallback callback + public void onWithRecallGlobalScene(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { onWithRecallGlobalScene(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void onWithTimedOff(DefaultClusterCallback callback - , Integer onOffControl, Integer onTime, Integer offWaitTime) { + public void onWithTimedOff( + DefaultClusterCallback callback, + Integer onOffControl, + Integer onTime, + Integer offWaitTime) { onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, null); } - public void onWithTimedOff(DefaultClusterCallback callback - , Integer onOffControl, Integer onTime, Integer offWaitTime - , int timedInvokeTimeoutMs) { - onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs); + public void onWithTimedOff( + DefaultClusterCallback callback, + Integer onOffControl, + Integer onTime, + Integer offWaitTime, + int timedInvokeTimeoutMs) { + onWithTimedOff( + chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs); } - public void toggle(DefaultClusterCallback callback - ) { + public void toggle(DefaultClusterCallback callback) { toggle(chipClusterPtr, callback, null); } - public void toggle(DefaultClusterCallback callback + public void toggle(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { toggle(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void off(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void offWithEffect(long chipClusterPtr, DefaultClusterCallback Callback - , Integer effectId, Integer effectVariant - , @Nullable Integer timedInvokeTimeoutMs); - private native void on(long chipClusterPtr, DefaultClusterCallback Callback + private native void off( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void onWithRecallGlobalScene(long chipClusterPtr, DefaultClusterCallback Callback + private native void offWithEffect( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer effectId, + Integer effectVariant, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void onWithTimedOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer onOffControl, Integer onTime, Integer offWaitTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void toggle(long chipClusterPtr, DefaultClusterCallback Callback + private native void on( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); + private native void onWithRecallGlobalScene( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void onWithTimedOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer onOffControl, + Integer onTime, + Integer offWaitTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void toggle( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readOnOffAttribute( - BooleanAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readOnOffAttribute(BooleanAttributeCallback callback) { readOnOffAttribute(chipClusterPtr, callback); } + public void subscribeOnOffAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGlobalSceneControlAttribute( - BooleanAttributeCallback callback - ) { + public void readGlobalSceneControlAttribute(BooleanAttributeCallback callback) { readGlobalSceneControlAttribute(chipClusterPtr, callback); } + public void subscribeGlobalSceneControlAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeGlobalSceneControlAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readOnTimeAttribute(IntegerAttributeCallback callback) { readOnTimeAttribute(chipClusterPtr, callback); } + public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOffWaitTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readOffWaitTimeAttribute(IntegerAttributeCallback callback) { readOffWaitTimeAttribute(chipClusterPtr, callback); } + public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOffWaitTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOffWaitTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOffWaitTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOffWaitTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOffWaitTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpOnOffAttribute( - IntegerAttributeCallback callback - ) { + public void readStartUpOnOffAttribute(IntegerAttributeCallback callback) { readStartUpOnOffAttribute(chipClusterPtr, callback); } + public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpOnOffAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeStartUpOnOffAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeStartUpOnOffAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeStartUpOnOffAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartUpOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOnOffAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeOnOffAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readGlobalSceneControlAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeGlobalSceneControlAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOnTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOnTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOffWaitTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOffWaitTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOffWaitTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartUpOnOffAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeStartUpOnOffAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeStartUpOnOffAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readOnOffAttribute(long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeOnOffAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readGlobalSceneControlAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeGlobalSceneControlAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnTimeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOnTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOffWaitTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOffWaitTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOffWaitTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartUpOnOffAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeStartUpOnOffAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeStartUpOnOffAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 OnOffSwitchConfigurationCluster extends BaseChipCluster { @@ -9079,96 +9964,91 @@ public OnOffSwitchConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readSwitchTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readSwitchTypeAttribute(IntegerAttributeCallback callback) { readSwitchTypeAttribute(chipClusterPtr, callback); } + public void subscribeSwitchTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSwitchTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSwitchActionsAttribute( - IntegerAttributeCallback callback - ) { + public void readSwitchActionsAttribute(IntegerAttributeCallback callback) { readSwitchActionsAttribute(chipClusterPtr, callback); } + public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value) { writeSwitchActionsAttribute(chipClusterPtr, callback, value, null); } - public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSwitchActionsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSwitchActionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeSwitchActionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSwitchActionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSwitchTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSwitchTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSwitchActionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeSwitchActionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSwitchActionsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readSwitchTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSwitchTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSwitchActionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeSwitchActionsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSwitchActionsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class OperationalCredentialsCluster extends BaseChipCluster { @@ -9181,131 +10061,183 @@ public OperationalCredentialsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId) { - addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminNode, adminVendorId, null); - } - - public void addNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId - , int timedInvokeTimeoutMs) { - addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminNode, adminVendorId, timedInvokeTimeoutMs); - } - - public void addTrustedRootCertificate(DefaultClusterCallback callback - , byte[] rootCertificate) { + public void addNOC( + NOCResponseCallback callback, + byte[] NOCValue, + Optional ICACValue, + byte[] IPKValue, + Long caseAdminNode, + Integer adminVendorId) { + addNOC( + chipClusterPtr, + callback, + NOCValue, + ICACValue, + IPKValue, + caseAdminNode, + adminVendorId, + null); + } + + public void addNOC( + NOCResponseCallback callback, + byte[] NOCValue, + Optional ICACValue, + byte[] IPKValue, + Long caseAdminNode, + Integer adminVendorId, + int timedInvokeTimeoutMs) { + addNOC( + chipClusterPtr, + callback, + NOCValue, + ICACValue, + IPKValue, + caseAdminNode, + adminVendorId, + timedInvokeTimeoutMs); + } + + public void addTrustedRootCertificate(DefaultClusterCallback callback, byte[] rootCertificate) { addTrustedRootCertificate(chipClusterPtr, callback, rootCertificate, null); } - public void addTrustedRootCertificate(DefaultClusterCallback callback - , byte[] rootCertificate - , int timedInvokeTimeoutMs) { + public void addTrustedRootCertificate( + DefaultClusterCallback callback, byte[] rootCertificate, int timedInvokeTimeoutMs) { addTrustedRootCertificate(chipClusterPtr, callback, rootCertificate, timedInvokeTimeoutMs); } - public void attestationRequest(AttestationResponseCallback callback - , byte[] attestationNonce) { + public void attestationRequest(AttestationResponseCallback callback, byte[] attestationNonce) { attestationRequest(chipClusterPtr, callback, attestationNonce, null); } - public void attestationRequest(AttestationResponseCallback callback - , byte[] attestationNonce - , int timedInvokeTimeoutMs) { + public void attestationRequest( + AttestationResponseCallback callback, byte[] attestationNonce, int timedInvokeTimeoutMs) { attestationRequest(chipClusterPtr, callback, attestationNonce, timedInvokeTimeoutMs); } - public void certificateChainRequest(CertificateChainResponseCallback callback - , Integer certificateType) { + public void certificateChainRequest( + CertificateChainResponseCallback callback, Integer certificateType) { certificateChainRequest(chipClusterPtr, callback, certificateType, null); } - public void certificateChainRequest(CertificateChainResponseCallback callback - , Integer certificateType - , int timedInvokeTimeoutMs) { + public void certificateChainRequest( + CertificateChainResponseCallback callback, + Integer certificateType, + int timedInvokeTimeoutMs) { certificateChainRequest(chipClusterPtr, callback, certificateType, timedInvokeTimeoutMs); } - public void opCSRRequest(OpCSRResponseCallback callback - , byte[] CSRNonce) { + public void opCSRRequest(OpCSRResponseCallback callback, byte[] CSRNonce) { opCSRRequest(chipClusterPtr, callback, CSRNonce, null); } - public void opCSRRequest(OpCSRResponseCallback callback - , byte[] CSRNonce - , int timedInvokeTimeoutMs) { + public void opCSRRequest( + OpCSRResponseCallback callback, byte[] CSRNonce, int timedInvokeTimeoutMs) { opCSRRequest(chipClusterPtr, callback, CSRNonce, timedInvokeTimeoutMs); } - public void removeFabric(NOCResponseCallback callback - , Integer fabricIndex) { + public void removeFabric(NOCResponseCallback callback, Integer fabricIndex) { removeFabric(chipClusterPtr, callback, fabricIndex, null); } - public void removeFabric(NOCResponseCallback callback - , Integer fabricIndex - , int timedInvokeTimeoutMs) { + public void removeFabric( + NOCResponseCallback callback, Integer fabricIndex, int timedInvokeTimeoutMs) { removeFabric(chipClusterPtr, callback, fabricIndex, timedInvokeTimeoutMs); } - public void removeTrustedRootCertificate(DefaultClusterCallback callback - , byte[] trustedRootIdentifier) { + public void removeTrustedRootCertificate( + DefaultClusterCallback callback, byte[] trustedRootIdentifier) { removeTrustedRootCertificate(chipClusterPtr, callback, trustedRootIdentifier, null); } - public void removeTrustedRootCertificate(DefaultClusterCallback callback - , byte[] trustedRootIdentifier - , int timedInvokeTimeoutMs) { - removeTrustedRootCertificate(chipClusterPtr, callback, trustedRootIdentifier, timedInvokeTimeoutMs); + public void removeTrustedRootCertificate( + DefaultClusterCallback callback, byte[] trustedRootIdentifier, int timedInvokeTimeoutMs) { + removeTrustedRootCertificate( + chipClusterPtr, callback, trustedRootIdentifier, timedInvokeTimeoutMs); } - public void updateFabricLabel(NOCResponseCallback callback - , String label) { + public void updateFabricLabel(NOCResponseCallback callback, String label) { updateFabricLabel(chipClusterPtr, callback, label, null); } - public void updateFabricLabel(NOCResponseCallback callback - , String label - , int timedInvokeTimeoutMs) { + public void updateFabricLabel( + NOCResponseCallback callback, String label, int timedInvokeTimeoutMs) { updateFabricLabel(chipClusterPtr, callback, label, timedInvokeTimeoutMs); } - public void updateNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue) { + public void updateNOC( + NOCResponseCallback callback, byte[] NOCValue, Optional ICACValue) { updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, null); } - public void updateNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue - , int timedInvokeTimeoutMs) { + public void updateNOC( + NOCResponseCallback callback, + byte[] NOCValue, + Optional ICACValue, + int timedInvokeTimeoutMs) { updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, timedInvokeTimeoutMs); } - private native void addNOC(long chipClusterPtr, NOCResponseCallback Callback - , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId - , @Nullable Integer timedInvokeTimeoutMs); - private native void addTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback Callback - , byte[] rootCertificate - , @Nullable Integer timedInvokeTimeoutMs); - private native void attestationRequest(long chipClusterPtr, AttestationResponseCallback Callback - , byte[] attestationNonce - , @Nullable Integer timedInvokeTimeoutMs); - private native void certificateChainRequest(long chipClusterPtr, CertificateChainResponseCallback Callback - , Integer certificateType - , @Nullable Integer timedInvokeTimeoutMs); - private native void opCSRRequest(long chipClusterPtr, OpCSRResponseCallback Callback - , byte[] CSRNonce - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeFabric(long chipClusterPtr, NOCResponseCallback Callback - , Integer fabricIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback Callback - , byte[] trustedRootIdentifier - , @Nullable Integer timedInvokeTimeoutMs); - private native void updateFabricLabel(long chipClusterPtr, NOCResponseCallback Callback - , String label - , @Nullable Integer timedInvokeTimeoutMs); - private native void updateNOC(long chipClusterPtr, NOCResponseCallback Callback - , byte[] NOCValue, Optional ICACValue - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addNOC( + long chipClusterPtr, + NOCResponseCallback Callback, + byte[] NOCValue, + Optional ICACValue, + byte[] IPKValue, + Long caseAdminNode, + Integer adminVendorId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void addTrustedRootCertificate( + long chipClusterPtr, + DefaultClusterCallback Callback, + byte[] rootCertificate, + @Nullable Integer timedInvokeTimeoutMs); + + private native void attestationRequest( + long chipClusterPtr, + AttestationResponseCallback Callback, + byte[] attestationNonce, + @Nullable Integer timedInvokeTimeoutMs); + + private native void certificateChainRequest( + long chipClusterPtr, + CertificateChainResponseCallback Callback, + Integer certificateType, + @Nullable Integer timedInvokeTimeoutMs); + + private native void opCSRRequest( + long chipClusterPtr, + OpCSRResponseCallback Callback, + byte[] CSRNonce, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeFabric( + long chipClusterPtr, + NOCResponseCallback Callback, + Integer fabricIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeTrustedRootCertificate( + long chipClusterPtr, + DefaultClusterCallback Callback, + byte[] trustedRootIdentifier, + @Nullable Integer timedInvokeTimeoutMs); + + private native void updateFabricLabel( + long chipClusterPtr, + NOCResponseCallback Callback, + String label, + @Nullable Integer timedInvokeTimeoutMs); + + private native void updateNOC( + long chipClusterPtr, + NOCResponseCallback Callback, + byte[] NOCValue, + Optional ICACValue, + @Nullable Integer timedInvokeTimeoutMs); + public interface AttestationResponseCallback { void onSuccess(byte[] attestationElements, byte[] signature); @@ -9330,184 +10262,177 @@ public interface OpCSRResponseCallback { void onError(Exception error); } + public interface NOCsAttributeCallback { + void onSuccess(List valueList); - public interface NOCsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface FabricsListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface TrustedRootCertificatesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentFabricIndexAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface FabricsListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface TrustedRootCertificatesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readNOCsAttribute( - NOCsAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public interface CurrentFabricIndexAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readNOCsAttribute(NOCsAttributeCallback callback) { readNOCsAttribute(chipClusterPtr, callback); } + public void subscribeNOCsAttribute( - NOCsAttributeCallback callback - , - int minInterval, int maxInterval) { + NOCsAttributeCallback callback, int minInterval, int maxInterval) { subscribeNOCsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFabricsListAttribute( - FabricsListAttributeCallback callback - ) { + public void readFabricsListAttribute(FabricsListAttributeCallback callback) { readFabricsListAttribute(chipClusterPtr, callback); } + public void subscribeFabricsListAttribute( - FabricsListAttributeCallback callback - , - int minInterval, int maxInterval) { + FabricsListAttributeCallback callback, int minInterval, int maxInterval) { subscribeFabricsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedFabricsAttribute( - IntegerAttributeCallback callback - ) { + public void readSupportedFabricsAttribute(IntegerAttributeCallback callback) { readSupportedFabricsAttribute(chipClusterPtr, callback); } + public void subscribeSupportedFabricsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCommissionedFabricsAttribute( - IntegerAttributeCallback callback - ) { + public void readCommissionedFabricsAttribute(IntegerAttributeCallback callback) { readCommissionedFabricsAttribute(chipClusterPtr, callback); } + public void subscribeCommissionedFabricsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCommissionedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTrustedRootCertificatesAttribute( - TrustedRootCertificatesAttributeCallback callback - ) { + TrustedRootCertificatesAttributeCallback callback) { readTrustedRootCertificatesAttribute(chipClusterPtr, callback); } + public void subscribeTrustedRootCertificatesAttribute( - TrustedRootCertificatesAttributeCallback callback - , - int minInterval, int maxInterval) { + TrustedRootCertificatesAttributeCallback callback, int minInterval, int maxInterval) { subscribeTrustedRootCertificatesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentFabricIndexAttribute( - CurrentFabricIndexAttributeCallback callback - ) { + public void readCurrentFabricIndexAttribute(CurrentFabricIndexAttributeCallback callback) { readCurrentFabricIndexAttribute(chipClusterPtr, callback); } + public void subscribeCurrentFabricIndexAttribute( - CurrentFabricIndexAttributeCallback callback - , - int minInterval, int maxInterval) { + CurrentFabricIndexAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNOCsAttribute(long chipClusterPtr, - NOCsAttributeCallback callback - ); - private native void subscribeNOCsAttribute(long chipClusterPtr, - NOCsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readFabricsListAttribute(long chipClusterPtr, - FabricsListAttributeCallback callback - ); - private native void subscribeFabricsListAttribute(long chipClusterPtr, - FabricsListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readSupportedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSupportedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCommissionedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCommissionedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTrustedRootCertificatesAttribute(long chipClusterPtr, - TrustedRootCertificatesAttributeCallback callback - ); - private native void subscribeTrustedRootCertificatesAttribute(long chipClusterPtr, - TrustedRootCertificatesAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentFabricIndexAttribute(long chipClusterPtr, - CurrentFabricIndexAttributeCallback callback - ); - private native void subscribeCurrentFabricIndexAttribute(long chipClusterPtr, - CurrentFabricIndexAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readNOCsAttribute(long chipClusterPtr, NOCsAttributeCallback callback); + + private native void subscribeNOCsAttribute( + long chipClusterPtr, NOCsAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFabricsListAttribute( + long chipClusterPtr, FabricsListAttributeCallback callback); + + private native void subscribeFabricsListAttribute( + long chipClusterPtr, + FabricsListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSupportedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSupportedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCommissionedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCommissionedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTrustedRootCertificatesAttribute( + long chipClusterPtr, TrustedRootCertificatesAttributeCallback callback); + + private native void subscribeTrustedRootCertificatesAttribute( + long chipClusterPtr, + TrustedRootCertificatesAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentFabricIndexAttribute( + long chipClusterPtr, CurrentFabricIndexAttributeCallback callback); + + private native void subscribeCurrentFabricIndexAttribute( + long chipClusterPtr, + CurrentFabricIndexAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class PowerSourceCluster extends BaseChipCluster { @@ -9520,244 +10445,208 @@ public PowerSourceCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface ActiveBatteryFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface ActiveBatteryFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readStatusAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readStatusAttribute(IntegerAttributeCallback callback) { readStatusAttribute(chipClusterPtr, callback); } + public void subscribeStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOrderAttribute( - IntegerAttributeCallback callback - ) { + public void readOrderAttribute(IntegerAttributeCallback callback) { readOrderAttribute(chipClusterPtr, callback); } + public void subscribeOrderAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOrderAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDescriptionAttribute( - CharStringAttributeCallback callback - ) { + public void readDescriptionAttribute(CharStringAttributeCallback callback) { readDescriptionAttribute(chipClusterPtr, callback); } + public void subscribeDescriptionAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryVoltageAttribute( - LongAttributeCallback callback - ) { + public void readBatteryVoltageAttribute(LongAttributeCallback callback) { readBatteryVoltageAttribute(chipClusterPtr, callback); } + public void subscribeBatteryVoltageAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryPercentRemainingAttribute( - IntegerAttributeCallback callback - ) { + public void readBatteryPercentRemainingAttribute(IntegerAttributeCallback callback) { readBatteryPercentRemainingAttribute(chipClusterPtr, callback); } + public void subscribeBatteryPercentRemainingAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryPercentRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryTimeRemainingAttribute( - LongAttributeCallback callback - ) { + public void readBatteryTimeRemainingAttribute(LongAttributeCallback callback) { readBatteryTimeRemainingAttribute(chipClusterPtr, callback); } + public void subscribeBatteryTimeRemainingAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryTimeRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryChargeLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readBatteryChargeLevelAttribute(IntegerAttributeCallback callback) { readBatteryChargeLevelAttribute(chipClusterPtr, callback); } + public void subscribeBatteryChargeLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryChargeLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveBatteryFaultsAttribute( - ActiveBatteryFaultsAttributeCallback callback - ) { + public void readActiveBatteryFaultsAttribute(ActiveBatteryFaultsAttributeCallback callback) { readActiveBatteryFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveBatteryFaultsAttribute( - ActiveBatteryFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveBatteryFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveBatteryFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryChargeStateAttribute( - IntegerAttributeCallback callback - ) { + public void readBatteryChargeStateAttribute(IntegerAttributeCallback callback) { readBatteryChargeStateAttribute(chipClusterPtr, callback); } + public void subscribeBatteryChargeStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryChargeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOrderAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOrderAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryVoltageAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBatteryVoltageAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryPercentRemainingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBatteryPercentRemainingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryTimeRemainingAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBatteryTimeRemainingAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryChargeLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBatteryChargeLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveBatteryFaultsAttribute(long chipClusterPtr, - ActiveBatteryFaultsAttributeCallback callback - ); - private native void subscribeActiveBatteryFaultsAttribute(long chipClusterPtr, - ActiveBatteryFaultsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readBatteryChargeStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBatteryChargeStateAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readStatusAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOrderAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOrderAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDescriptionAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeDescriptionAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readBatteryVoltageAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBatteryVoltageAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBatteryPercentRemainingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBatteryPercentRemainingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBatteryTimeRemainingAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBatteryTimeRemainingAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBatteryChargeLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBatteryChargeLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveBatteryFaultsAttribute( + long chipClusterPtr, ActiveBatteryFaultsAttributeCallback callback); + + private native void subscribeActiveBatteryFaultsAttribute( + long chipClusterPtr, + ActiveBatteryFaultsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readBatteryChargeStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBatteryChargeStateAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 PowerSourceConfigurationCluster extends BaseChipCluster { @@ -9770,73 +10659,69 @@ public PowerSourceConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SourcesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface SourcesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readSourcesAttribute( - SourcesAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readSourcesAttribute(SourcesAttributeCallback callback) { readSourcesAttribute(chipClusterPtr, callback); } + public void subscribeSourcesAttribute( - SourcesAttributeCallback callback - , - int minInterval, int maxInterval) { + SourcesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSourcesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSourcesAttribute(long chipClusterPtr, - SourcesAttributeCallback callback - ); - private native void subscribeSourcesAttribute(long chipClusterPtr, - SourcesAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readSourcesAttribute( + long chipClusterPtr, SourcesAttributeCallback callback); + + private native void subscribeSourcesAttribute( + long chipClusterPtr, SourcesAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class PressureMeasurementCluster extends BaseChipCluster { @@ -9849,106 +10734,91 @@ public PressureMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class PumpConfigurationAndControlCluster extends BaseChipCluster { @@ -9961,701 +10831,614 @@ public PumpConfigurationAndControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LifetimeRunningHoursAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface LifetimeEnergyConsumedAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface LifetimeRunningHoursAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface LifetimeEnergyConsumedAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); - public void readMaxPressureAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMaxPressureAttribute(IntegerAttributeCallback callback) { readMaxPressureAttribute(chipClusterPtr, callback); } + public void subscribeMaxPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxSpeedAttribute(IntegerAttributeCallback callback) { readMaxSpeedAttribute(chipClusterPtr, callback); } + public void subscribeMaxSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxFlowAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxFlowAttribute(IntegerAttributeCallback callback) { readMaxFlowAttribute(chipClusterPtr, callback); } + public void subscribeMaxFlowAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstPressureAttribute(IntegerAttributeCallback callback) { readMinConstPressureAttribute(chipClusterPtr, callback); } + public void subscribeMinConstPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstPressureAttribute(IntegerAttributeCallback callback) { readMaxConstPressureAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinCompPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMinCompPressureAttribute(IntegerAttributeCallback callback) { readMinCompPressureAttribute(chipClusterPtr, callback); } + public void subscribeMinCompPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxCompPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxCompPressureAttribute(IntegerAttributeCallback callback) { readMaxCompPressureAttribute(chipClusterPtr, callback); } + public void subscribeMaxCompPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstSpeedAttribute(IntegerAttributeCallback callback) { readMinConstSpeedAttribute(chipClusterPtr, callback); } + public void subscribeMinConstSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstSpeedAttribute(IntegerAttributeCallback callback) { readMaxConstSpeedAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstFlowAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstFlowAttribute(IntegerAttributeCallback callback) { readMinConstFlowAttribute(chipClusterPtr, callback); } + public void subscribeMinConstFlowAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstFlowAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstFlowAttribute(IntegerAttributeCallback callback) { readMaxConstFlowAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstFlowAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstTempAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstTempAttribute(IntegerAttributeCallback callback) { readMinConstTempAttribute(chipClusterPtr, callback); } + public void subscribeMinConstTempAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstTempAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstTempAttribute(IntegerAttributeCallback callback) { readMaxConstTempAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstTempAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPumpStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readPumpStatusAttribute(IntegerAttributeCallback callback) { readPumpStatusAttribute(chipClusterPtr, callback); } + public void subscribePumpStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePumpStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEffectiveOperationModeAttribute( - IntegerAttributeCallback callback - ) { + public void readEffectiveOperationModeAttribute(IntegerAttributeCallback callback) { readEffectiveOperationModeAttribute(chipClusterPtr, callback); } + public void subscribeEffectiveOperationModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEffectiveOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEffectiveControlModeAttribute( - IntegerAttributeCallback callback - ) { + public void readEffectiveControlModeAttribute(IntegerAttributeCallback callback) { readEffectiveControlModeAttribute(chipClusterPtr, callback); } + public void subscribeEffectiveControlModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEffectiveControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCapacityAttribute( - IntegerAttributeCallback callback - ) { + public void readCapacityAttribute(IntegerAttributeCallback callback) { readCapacityAttribute(chipClusterPtr, callback); } + public void subscribeCapacityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readSpeedAttribute(IntegerAttributeCallback callback) { readSpeedAttribute(chipClusterPtr, callback); } + public void subscribeSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLifetimeRunningHoursAttribute( - LifetimeRunningHoursAttributeCallback callback - ) { + public void readLifetimeRunningHoursAttribute(LifetimeRunningHoursAttributeCallback callback) { readLifetimeRunningHoursAttribute(chipClusterPtr, callback); } + public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value) { writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, null); } - public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeLifetimeRunningHoursAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLifetimeRunningHoursAttribute( - LifetimeRunningHoursAttributeCallback callback - , - int minInterval, int maxInterval) { + LifetimeRunningHoursAttributeCallback callback, int minInterval, int maxInterval) { subscribeLifetimeRunningHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPowerAttribute( - LongAttributeCallback callback - ) { + public void readPowerAttribute(LongAttributeCallback callback) { readPowerAttribute(chipClusterPtr, callback); } + public void subscribePowerAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readLifetimeEnergyConsumedAttribute( - LifetimeEnergyConsumedAttributeCallback callback - ) { + LifetimeEnergyConsumedAttributeCallback callback) { readLifetimeEnergyConsumedAttribute(chipClusterPtr, callback); } + public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value) { writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, null); } - public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeLifetimeEnergyConsumedAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLifetimeEnergyConsumedAttribute( - LifetimeEnergyConsumedAttributeCallback callback - , - int minInterval, int maxInterval) { + LifetimeEnergyConsumedAttributeCallback callback, int minInterval, int maxInterval) { subscribeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperationModeAttribute( - IntegerAttributeCallback callback - ) { + public void readOperationModeAttribute(IntegerAttributeCallback callback) { readOperationModeAttribute(chipClusterPtr, callback); } + public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value) { writeOperationModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOperationModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOperationModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOperationModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readControlModeAttribute( - IntegerAttributeCallback callback - ) { + public void readControlModeAttribute(IntegerAttributeCallback callback) { readControlModeAttribute(chipClusterPtr, callback); } + public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value) { writeControlModeAttribute(chipClusterPtr, callback, value, null); } - public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeControlModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeControlModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeControlModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAlarmMaskAttribute( - IntegerAttributeCallback callback - ) { + public void readAlarmMaskAttribute(IntegerAttributeCallback callback) { readAlarmMaskAttribute(chipClusterPtr, callback); } + public void subscribeAlarmMaskAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAlarmMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMaxPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPumpStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePumpStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEffectiveOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEffectiveOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEffectiveControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEffectiveControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCapacityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCapacityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLifetimeRunningHoursAttribute(long chipClusterPtr, - LifetimeRunningHoursAttributeCallback callback - ); - - private native void writeLifetimeRunningHoursAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLifetimeRunningHoursAttribute(long chipClusterPtr, - LifetimeRunningHoursAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readPowerAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePowerAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLifetimeEnergyConsumedAttribute(long chipClusterPtr, - LifetimeEnergyConsumedAttributeCallback callback - ); - - private native void writeLifetimeEnergyConsumedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLifetimeEnergyConsumedAttribute(long chipClusterPtr, - LifetimeEnergyConsumedAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOperationModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeControlModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAlarmMaskAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAlarmMaskAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); - } + private native void readMaxPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public static class RelativeHumidityMeasurementCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1029L; + private native void subscribeMaxPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void readMaxSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - @Override - public native long initWithDevice(long devicePtr, int endpointId); + private native void subscribeMaxSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void readMaxFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { - readMeasuredValueAttribute(chipClusterPtr, callback); - } - public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeMaxFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { - readMinMeasuredValueAttribute(chipClusterPtr, callback); - } - public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readMinConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { - readMaxMeasuredValueAttribute(chipClusterPtr, callback); - } - public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeMinConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { - readToleranceAttribute(chipClusterPtr, callback); - } - public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readMaxConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { - readAttributeListAttribute(chipClusterPtr, callback); - } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeMaxConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { - readClusterRevisionAttribute(chipClusterPtr, callback); + private native void readMinCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPumpStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePumpStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEffectiveOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEffectiveOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEffectiveControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEffectiveControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCapacityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCapacityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSpeedAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLifetimeRunningHoursAttribute( + long chipClusterPtr, LifetimeRunningHoursAttributeCallback callback); + + private native void writeLifetimeRunningHoursAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLifetimeRunningHoursAttribute( + long chipClusterPtr, + LifetimeRunningHoursAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPowerAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePowerAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLifetimeEnergyConsumedAttribute( + long chipClusterPtr, LifetimeEnergyConsumedAttributeCallback callback); + + private native void writeLifetimeEnergyConsumedAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLifetimeEnergyConsumedAttribute( + long chipClusterPtr, + LifetimeEnergyConsumedAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOperationModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeControlModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAlarmMaskAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAlarmMaskAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 RelativeHumidityMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1029L; + + public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + + public void subscribeMeasuredValueAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + + public void subscribeMinMeasuredValueAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + + public void subscribeMaxMeasuredValueAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readToleranceAttribute(IntegerAttributeCallback callback) { + readToleranceAttribute(chipClusterPtr, callback); + } + + public void subscribeToleranceAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeToleranceAttribute(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 readClusterRevisionAttribute(IntegerAttributeCallback callback) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ScenesCluster extends BaseChipCluster { @@ -10668,103 +11451,163 @@ public ScenesCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addScene(AddSceneResponseCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { - addScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, sceneName, extensionFieldSets, null); - } - - public void addScene(AddSceneResponseCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets - , int timedInvokeTimeoutMs) { - addScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, sceneName, extensionFieldSets, timedInvokeTimeoutMs); - } - - public void getSceneMembership(GetSceneMembershipResponseCallback callback - , Integer groupId) { + public void addScene( + AddSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets) { + addScene( + chipClusterPtr, + callback, + groupId, + sceneId, + transitionTime, + sceneName, + extensionFieldSets, + null); + } + + public void addScene( + AddSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets, + int timedInvokeTimeoutMs) { + addScene( + chipClusterPtr, + callback, + groupId, + sceneId, + transitionTime, + sceneName, + extensionFieldSets, + timedInvokeTimeoutMs); + } + + public void getSceneMembership(GetSceneMembershipResponseCallback callback, Integer groupId) { getSceneMembership(chipClusterPtr, callback, groupId, null); } - public void getSceneMembership(GetSceneMembershipResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void getSceneMembership( + GetSceneMembershipResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { getSceneMembership(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void recallScene(DefaultClusterCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime) { + public void recallScene( + DefaultClusterCallback callback, Integer groupId, Integer sceneId, Integer transitionTime) { recallScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, null); } - public void recallScene(DefaultClusterCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime - , int timedInvokeTimeoutMs) { + public void recallScene( + DefaultClusterCallback callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + int timedInvokeTimeoutMs) { recallScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, timedInvokeTimeoutMs); } - public void removeAllScenes(RemoveAllScenesResponseCallback callback - , Integer groupId) { + public void removeAllScenes(RemoveAllScenesResponseCallback callback, Integer groupId) { removeAllScenes(chipClusterPtr, callback, groupId, null); } - public void removeAllScenes(RemoveAllScenesResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void removeAllScenes( + RemoveAllScenesResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { removeAllScenes(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void removeScene(RemoveSceneResponseCallback callback - , Integer groupId, Integer sceneId) { + public void removeScene( + RemoveSceneResponseCallback callback, Integer groupId, Integer sceneId) { removeScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void removeScene(RemoveSceneResponseCallback callback - , Integer groupId, Integer sceneId - , int timedInvokeTimeoutMs) { + public void removeScene( + RemoveSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + int timedInvokeTimeoutMs) { removeScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - public void storeScene(StoreSceneResponseCallback callback - , Integer groupId, Integer sceneId) { + public void storeScene(StoreSceneResponseCallback callback, Integer groupId, Integer sceneId) { storeScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void storeScene(StoreSceneResponseCallback callback - , Integer groupId, Integer sceneId - , int timedInvokeTimeoutMs) { + public void storeScene( + StoreSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + int timedInvokeTimeoutMs) { storeScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - public void viewScene(ViewSceneResponseCallback callback - , Integer groupId, Integer sceneId) { + public void viewScene(ViewSceneResponseCallback callback, Integer groupId, Integer sceneId) { viewScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void viewScene(ViewSceneResponseCallback callback - , Integer groupId, Integer sceneId - , int timedInvokeTimeoutMs) { + public void viewScene( + ViewSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + int timedInvokeTimeoutMs) { viewScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - private native void addScene(long chipClusterPtr, AddSceneResponseCallback Callback - , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets - , @Nullable Integer timedInvokeTimeoutMs); - private native void getSceneMembership(long chipClusterPtr, GetSceneMembershipResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); - private native void recallScene(long chipClusterPtr, DefaultClusterCallback Callback - , Integer groupId, Integer sceneId, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeAllScenes(long chipClusterPtr, RemoveAllScenesResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeScene(long chipClusterPtr, RemoveSceneResponseCallback Callback - , Integer groupId, Integer sceneId - , @Nullable Integer timedInvokeTimeoutMs); - private native void storeScene(long chipClusterPtr, StoreSceneResponseCallback Callback - , Integer groupId, Integer sceneId - , @Nullable Integer timedInvokeTimeoutMs); - private native void viewScene(long chipClusterPtr, ViewSceneResponseCallback Callback - , Integer groupId, Integer sceneId - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addScene( + long chipClusterPtr, + AddSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getSceneMembership( + long chipClusterPtr, + GetSceneMembershipResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void recallScene( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeAllScenes( + long chipClusterPtr, + RemoveAllScenesResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeScene( + long chipClusterPtr, + RemoveSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void storeScene( + long chipClusterPtr, + StoreSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void viewScene( + long chipClusterPtr, + ViewSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + @Nullable Integer timedInvokeTimeoutMs); + public interface AddSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); @@ -10772,7 +11615,12 @@ public interface AddSceneResponseCallback { } public interface GetSceneMembershipResponseCallback { - void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList); + void onSuccess( + Integer status, + Integer capacity, + Integer groupId, + Integer sceneCount, + ArrayList sceneList); void onError(Exception error); } @@ -10796,150 +11644,132 @@ public interface StoreSceneResponseCallback { } public interface ViewSceneResponseCallback { - void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets); + void onSuccess( + Integer status, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readSceneCountAttribute( - IntegerAttributeCallback callback - ) { + public void readSceneCountAttribute(IntegerAttributeCallback callback) { readSceneCountAttribute(chipClusterPtr, callback); } + public void subscribeSceneCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSceneCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentSceneAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentSceneAttribute(IntegerAttributeCallback callback) { readCurrentSceneAttribute(chipClusterPtr, callback); } + public void subscribeCurrentSceneAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentSceneAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentGroupAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentGroupAttribute(IntegerAttributeCallback callback) { readCurrentGroupAttribute(chipClusterPtr, callback); } + public void subscribeCurrentGroupAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentGroupAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSceneValidAttribute( - BooleanAttributeCallback callback - ) { + public void readSceneValidAttribute(BooleanAttributeCallback callback) { readSceneValidAttribute(chipClusterPtr, callback); } + public void subscribeSceneValidAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeSceneValidAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNameSupportAttribute( - IntegerAttributeCallback callback - ) { + public void readNameSupportAttribute(IntegerAttributeCallback callback) { readNameSupportAttribute(chipClusterPtr, callback); } + public void subscribeNameSupportAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSceneCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSceneCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentSceneAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentSceneAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentGroupAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentGroupAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSceneValidAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeSceneValidAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readSceneCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSceneCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentSceneAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentSceneAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentGroupAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentGroupAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSceneValidAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeSceneValidAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class SoftwareDiagnosticsCluster extends BaseChipCluster { @@ -10952,163 +11782,147 @@ public SoftwareDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetWatermarks(DefaultClusterCallback callback - ) { + public void resetWatermarks(DefaultClusterCallback callback) { resetWatermarks(chipClusterPtr, callback, null); } - public void resetWatermarks(DefaultClusterCallback callback + public void resetWatermarks(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { resetWatermarks(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void resetWatermarks(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void resetWatermarks( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface ThreadMetricsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface ThreadMetricsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readThreadMetricsAttribute( - ThreadMetricsAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readThreadMetricsAttribute(ThreadMetricsAttributeCallback callback) { readThreadMetricsAttribute(chipClusterPtr, callback); } + public void subscribeThreadMetricsAttribute( - ThreadMetricsAttributeCallback callback - , - int minInterval, int maxInterval) { + ThreadMetricsAttributeCallback callback, int minInterval, int maxInterval) { subscribeThreadMetricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapFreeAttribute( - LongAttributeCallback callback - ) { + public void readCurrentHeapFreeAttribute(LongAttributeCallback callback) { readCurrentHeapFreeAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHeapFreeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentHeapFreeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapUsedAttribute( - LongAttributeCallback callback - ) { + public void readCurrentHeapUsedAttribute(LongAttributeCallback callback) { readCurrentHeapUsedAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHeapUsedAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentHeapUsedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapHighWatermarkAttribute( - LongAttributeCallback callback - ) { + public void readCurrentHeapHighWatermarkAttribute(LongAttributeCallback callback) { readCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHeapHighWatermarkAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCurrentHeapHighWatermarkAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readThreadMetricsAttribute(long chipClusterPtr, - ThreadMetricsAttributeCallback callback - ); - private native void subscribeThreadMetricsAttribute(long chipClusterPtr, - ThreadMetricsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentHeapFreeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentHeapFreeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentHeapUsedAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentHeapUsedAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentHeapHighWatermarkAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentHeapHighWatermarkAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readThreadMetricsAttribute( + long chipClusterPtr, ThreadMetricsAttributeCallback callback); + + private native void subscribeThreadMetricsAttribute( + long chipClusterPtr, + ThreadMetricsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentHeapFreeAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentHeapFreeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentHeapUsedAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentHeapUsedAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentHeapHighWatermarkAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentHeapHighWatermarkAttribute( + long chipClusterPtr, LongAttributeCallback 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 SwitchCluster extends BaseChipCluster { @@ -11121,125 +11935,106 @@ public SwitchCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readNumberOfPositionsAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfPositionsAttribute(IntegerAttributeCallback callback) { readNumberOfPositionsAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfPositionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNumberOfPositionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentPositionAttribute(IntegerAttributeCallback callback) { readCurrentPositionAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMultiPressMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readMultiPressMaxAttribute(IntegerAttributeCallback callback) { readMultiPressMaxAttribute(chipClusterPtr, callback); } + public void subscribeMultiPressMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMultiPressMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNumberOfPositionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfPositionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMultiPressMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMultiPressMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readNumberOfPositionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfPositionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMultiPressMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMultiPressMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 TargetNavigatorCluster extends BaseChipCluster { @@ -11252,112 +12047,113 @@ public TargetNavigatorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void navigateTargetRequest(NavigateTargetResponseCallback callback - , Integer target, String data) { + public void navigateTargetRequest( + NavigateTargetResponseCallback callback, Integer target, String data) { navigateTargetRequest(chipClusterPtr, callback, target, data, null); } - public void navigateTargetRequest(NavigateTargetResponseCallback callback - , Integer target, String data - , int timedInvokeTimeoutMs) { + public void navigateTargetRequest( + NavigateTargetResponseCallback callback, + Integer target, + String data, + int timedInvokeTimeoutMs) { navigateTargetRequest(chipClusterPtr, callback, target, data, timedInvokeTimeoutMs); } - private native void navigateTargetRequest(long chipClusterPtr, NavigateTargetResponseCallback Callback - , Integer target, String data - , @Nullable Integer timedInvokeTimeoutMs); + + private native void navigateTargetRequest( + long chipClusterPtr, + NavigateTargetResponseCallback Callback, + Integer target, + String data, + @Nullable Integer timedInvokeTimeoutMs); + public interface NavigateTargetResponseCallback { void onSuccess(Integer status, String data); void onError(Exception error); } + public interface TargetNavigatorListAttributeCallback { + void onSuccess(List valueList); - public interface TargetNavigatorListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readTargetNavigatorListAttribute( - TargetNavigatorListAttributeCallback callback - ) { + public void readTargetNavigatorListAttribute(TargetNavigatorListAttributeCallback callback) { readTargetNavigatorListAttribute(chipClusterPtr, callback); } + public void subscribeTargetNavigatorListAttribute( - TargetNavigatorListAttributeCallback callback - , - int minInterval, int maxInterval) { + TargetNavigatorListAttributeCallback callback, int minInterval, int maxInterval) { subscribeTargetNavigatorListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentNavigatorTargetAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentNavigatorTargetAttribute(IntegerAttributeCallback callback) { readCurrentNavigatorTargetAttribute(chipClusterPtr, callback); } + public void subscribeCurrentNavigatorTargetAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentNavigatorTargetAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTargetNavigatorListAttribute(long chipClusterPtr, - TargetNavigatorListAttributeCallback callback - ); - private native void subscribeTargetNavigatorListAttribute(long chipClusterPtr, - TargetNavigatorListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentNavigatorTargetAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentNavigatorTargetAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readTargetNavigatorListAttribute( + long chipClusterPtr, TargetNavigatorListAttributeCallback callback); + + private native void subscribeTargetNavigatorListAttribute( + long chipClusterPtr, + TargetNavigatorListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentNavigatorTargetAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentNavigatorTargetAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class TemperatureMeasurementCluster extends BaseChipCluster { @@ -11370,2838 +12166,3268 @@ public TemperatureMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { + public void readToleranceAttribute(IntegerAttributeCallback callback) { readToleranceAttribute(chipClusterPtr, callback); } + public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class TestClusterCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1295L; + + public TestClusterCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void simpleStructEchoRequest( + SimpleStructResponseCallback callback, ChipStructs.TestClusterClusterSimpleStruct arg1) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, null); + } + + public void simpleStructEchoRequest( + SimpleStructResponseCallback callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + int timedInvokeTimeoutMs) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void test(DefaultClusterCallback callback) { + test(chipClusterPtr, callback, null); + } + + public void test(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + test(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testAddArguments( + TestAddArgumentsResponseCallback callback, Integer arg1, Integer arg2) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, null); + } + + public void testAddArguments( + TestAddArgumentsResponseCallback callback, + Integer arg1, + Integer arg2, + int timedInvokeTimeoutMs) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + } + + public void testEmitTestEventRequest( + TestEmitTestEventResponseCallback callback, Integer arg1, Integer arg2, Boolean arg3) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, null); + } + + public void testEmitTestEventRequest( + TestEmitTestEventResponseCallback callback, + Integer arg1, + Integer arg2, + Boolean arg3, + int timedInvokeTimeoutMs) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, timedInvokeTimeoutMs); + } + + public void testEnumsRequest(TestEnumsResponseCallback callback, Integer arg1, Integer arg2) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, null); + } + + public void testEnumsRequest( + TestEnumsResponseCallback callback, Integer arg1, Integer arg2, int timedInvokeTimeoutMs) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + } + + public void testListInt8UArgumentRequest( + BooleanResponseCallback callback, ArrayList arg1) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListInt8UArgumentRequest( + BooleanResponseCallback callback, ArrayList arg1, int timedInvokeTimeoutMs) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListInt8UReverseRequest( + TestListInt8UReverseResponseCallback callback, ArrayList arg1) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListInt8UReverseRequest( + TestListInt8UReverseResponseCallback callback, + ArrayList arg1, + int timedInvokeTimeoutMs) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListNestedStructListArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListNestedStructListArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1, + int timedInvokeTimeoutMs) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListStructArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListStructArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1, + int timedInvokeTimeoutMs) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testNestedStructArgumentRequest( + BooleanResponseCallback callback, ChipStructs.TestClusterClusterNestedStruct arg1) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNestedStructArgumentRequest( + BooleanResponseCallback callback, + ChipStructs.TestClusterClusterNestedStruct arg1, + int timedInvokeTimeoutMs) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testNestedStructListArgumentRequest( + BooleanResponseCallback callback, ChipStructs.TestClusterClusterNestedStructList arg1) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNestedStructListArgumentRequest( + BooleanResponseCallback callback, + ChipStructs.TestClusterClusterNestedStructList arg1, + int timedInvokeTimeoutMs) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testNotHandled(DefaultClusterCallback callback) { + testNotHandled(chipClusterPtr, callback, null); + } + + public void testNotHandled(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testNullableOptionalRequest( + TestNullableOptionalResponseCallback callback, @Nullable Optional arg1) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNullableOptionalRequest( + TestNullableOptionalResponseCallback callback, + @Nullable Optional arg1, + int timedInvokeTimeoutMs) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testSimpleOptionalArgumentRequest( + DefaultClusterCallback callback, Optional arg1) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testSimpleOptionalArgumentRequest( + DefaultClusterCallback callback, Optional arg1, int timedInvokeTimeoutMs) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testSpecific(TestSpecificResponseCallback callback) { + testSpecific(chipClusterPtr, callback, null); + } + + public void testSpecific(TestSpecificResponseCallback callback, int timedInvokeTimeoutMs) { + + testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testStructArgumentRequest( + BooleanResponseCallback callback, ChipStructs.TestClusterClusterSimpleStruct arg1) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testStructArgumentRequest( + BooleanResponseCallback callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + int timedInvokeTimeoutMs) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testUnknownCommand(DefaultClusterCallback callback) { + testUnknownCommand(chipClusterPtr, callback, null); + } + + public void testUnknownCommand(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void timedInvokeRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + private native void simpleStructEchoRequest( + long chipClusterPtr, + SimpleStructResponseCallback Callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void test( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testAddArguments( + long chipClusterPtr, + TestAddArgumentsResponseCallback Callback, + Integer arg1, + Integer arg2, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testEmitTestEventRequest( + long chipClusterPtr, + TestEmitTestEventResponseCallback Callback, + Integer arg1, + Integer arg2, + Boolean arg3, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testEnumsRequest( + long chipClusterPtr, + TestEnumsResponseCallback Callback, + Integer arg1, + Integer arg2, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListInt8UArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListInt8UReverseRequest( + long chipClusterPtr, + TestListInt8UReverseResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListNestedStructListArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListStructArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNestedStructArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ChipStructs.TestClusterClusterNestedStruct arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNestedStructListArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ChipStructs.TestClusterClusterNestedStructList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNotHandled( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNullableOptionalRequest( + long chipClusterPtr, + TestNullableOptionalResponseCallback Callback, + @Nullable Optional arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testSimpleOptionalArgumentRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Optional arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testSpecific( + long chipClusterPtr, + TestSpecificResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testStructArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testUnknownCommand( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void timedInvokeRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface BooleanResponseCallback { + void onSuccess(Boolean value); + + void onError(Exception error); + } + + public interface SimpleStructResponseCallback { + void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); + + void onError(Exception error); + } + + public interface TestAddArgumentsResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } + + public interface TestEmitTestEventResponseCallback { + void onSuccess(Long value); + + void onError(Exception error); + } + + public interface TestEnumsResponseCallback { + void onSuccess(Integer arg1, Integer arg2); + + void onError(Exception error); + } + + public interface TestListInt8UReverseResponseCallback { + void onSuccess(ArrayList arg1); + + void onError(Exception error); + } + + public interface TestNullableOptionalResponseCallback { + void onSuccess( + Boolean wasPresent, + Optional wasNull, + Optional value, + @Nullable Optional originalValue); + + void onError(Exception error); + } + + public interface TestSpecificResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } + + public interface ListInt8uAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListOctetStringAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListStructOctetStringAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface VendorIdAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListNullablesAndOptionalsStructAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListLongOctetStringAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBooleanAttributeCallback { + void onSuccess(@Nullable Boolean value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBitmap8AttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBitmap16AttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBitmap32AttributeCallback { + void onSuccess(@Nullable Long value); - public static class TestClusterCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1295L; + void onError(Exception ex); - public TestClusterCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); + default void onSubscriptionEstablished() {} } - @Override - public native long initWithDevice(long devicePtr, int endpointId); + public interface NullableBitmap64AttributeCallback { + void onSuccess(@Nullable Long value); - public void simpleStructEchoRequest(SimpleStructResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1) { - simpleStructEchoRequest(chipClusterPtr, callback, arg1, null); - } + void onError(Exception ex); - public void simpleStructEchoRequest(SimpleStructResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , int timedInvokeTimeoutMs) { - simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void test(DefaultClusterCallback callback - ) { - test(chipClusterPtr, callback, null); - } + public interface NullableInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); - public void test(DefaultClusterCallback callback + void onError(Exception ex); - , int timedInvokeTimeoutMs) { - test(chipClusterPtr, callback, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testAddArguments(TestAddArgumentsResponseCallback callback - , Integer arg1, Integer arg2) { - testAddArguments(chipClusterPtr, callback, arg1, arg2, null); - } + public interface NullableInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); - public void testAddArguments(TestAddArgumentsResponseCallback callback - , Integer arg1, Integer arg2 - , int timedInvokeTimeoutMs) { - testAddArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); - } + void onError(Exception ex); - public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback - , Integer arg1, Integer arg2, Boolean arg3) { - testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, null); + default void onSubscriptionEstablished() {} } - public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback - , Integer arg1, Integer arg2, Boolean arg3 - , int timedInvokeTimeoutMs) { - testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, timedInvokeTimeoutMs); - } + public interface NullableInt24uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testEnumsRequest(TestEnumsResponseCallback callback - , Integer arg1, Integer arg2) { - testEnumsRequest(chipClusterPtr, callback, arg1, arg2, null); - } + void onError(Exception ex); - public void testEnumsRequest(TestEnumsResponseCallback callback - , Integer arg1, Integer arg2 - , int timedInvokeTimeoutMs) { - testEnumsRequest(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testListInt8UArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1) { - testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null); - } + public interface NullableInt32uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testListInt8UArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + void onError(Exception ex); - public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback - , ArrayList arg1) { - testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null); + default void onSubscriptionEstablished() {} } - public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListInt8UReverseRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + public interface NullableInt40uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1) { - testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); - } + void onError(Exception ex); - public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testListStructArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1) { - testListStructArgumentRequest(chipClusterPtr, callback, arg1, null); - } + public interface NullableInt48uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testListStructArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + void onError(Exception ex); - public void testNestedStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStruct arg1) { - testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null); + default void onSubscriptionEstablished() {} } - public void testNestedStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStruct arg1 - , int timedInvokeTimeoutMs) { - testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + public interface NullableInt56uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testNestedStructListArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStructList arg1) { - testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); - } + void onError(Exception ex); - public void testNestedStructListArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStructList arg1 - , int timedInvokeTimeoutMs) { - testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testNotHandled(DefaultClusterCallback callback - ) { - testNotHandled(chipClusterPtr, callback, null); - } + public interface NullableInt64uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testNotHandled(DefaultClusterCallback callback + void onError(Exception ex); - , int timedInvokeTimeoutMs) { - testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback - , @Nullable Optional arg1) { - testNullableOptionalRequest(chipClusterPtr, callback, arg1, null); + public interface NullableInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback - , @Nullable Optional arg1 - , int timedInvokeTimeoutMs) { - testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + public interface NullableInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback - , Optional arg1) { - testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null); + public interface NullableInt24sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback - , Optional arg1 - , int timedInvokeTimeoutMs) { - testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + public interface NullableInt32sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSpecific(TestSpecificResponseCallback callback - ) { - testSpecific(chipClusterPtr, callback, null); + public interface NullableInt40sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSpecific(TestSpecificResponseCallback callback + public interface NullableInt48sAttributeCallback { + void onSuccess(@Nullable Long value); - , int timedInvokeTimeoutMs) { - testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1) { - testStructArgumentRequest(chipClusterPtr, callback, arg1, null); + public interface NullableInt56sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , int timedInvokeTimeoutMs) { - testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + public interface NullableInt64sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testUnknownCommand(DefaultClusterCallback callback - ) { - testUnknownCommand(chipClusterPtr, callback, null); + public interface NullableEnum8AttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testUnknownCommand(DefaultClusterCallback callback + public interface NullableEnum16AttributeCallback { + void onSuccess(@Nullable Integer value); - , int timedInvokeTimeoutMs) { - testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } + public interface NullableFloatSingleAttributeCallback { + void onSuccess(@Nullable Float value); - public void timedInvokeRequest(DefaultClusterCallback callback + void onError(Exception ex); - , int timedInvokeTimeoutMs) { - timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - private native void simpleStructEchoRequest(long chipClusterPtr, SimpleStructResponseCallback Callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void test(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void testAddArguments(long chipClusterPtr, TestAddArgumentsResponseCallback Callback - , Integer arg1, Integer arg2 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testEmitTestEventRequest(long chipClusterPtr, TestEmitTestEventResponseCallback Callback - , Integer arg1, Integer arg2, Boolean arg3 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testEnumsRequest(long chipClusterPtr, TestEnumsResponseCallback Callback - , Integer arg1, Integer arg2 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListInt8UArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListInt8UReverseRequest(long chipClusterPtr, TestListInt8UReverseResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNestedStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ChipStructs.TestClusterClusterNestedStruct arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ChipStructs.TestClusterClusterNestedStructList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNotHandled(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNullableOptionalRequest(long chipClusterPtr, TestNullableOptionalResponseCallback Callback - , @Nullable Optional arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testSimpleOptionalArgumentRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Optional arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testSpecific(long chipClusterPtr, TestSpecificResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void testStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testUnknownCommand(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void timedInvokeRequest(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - public interface BooleanResponseCallback { - void onSuccess(Boolean value); - void onError(Exception error); + public interface NullableFloatDoubleAttributeCallback { + void onSuccess(@Nullable Double value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface SimpleStructResponseCallback { - void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); + public interface NullableOctetStringAttributeCallback { + void onSuccess(@Nullable byte[] value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestAddArgumentsResponseCallback { - void onSuccess(Integer returnValue); + public interface NullableCharStringAttributeCallback { + void onSuccess(@Nullable String value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestEmitTestEventResponseCallback { - void onSuccess(Long value); + public interface NullableEnumAttrAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestEnumsResponseCallback { - void onSuccess(Integer arg1, Integer arg2); + public interface NullableRangeRestrictedInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestListInt8UReverseResponseCallback { - void onSuccess(ArrayList arg1); + public interface NullableRangeRestrictedInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestNullableOptionalResponseCallback { - void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue); + public interface NullableRangeRestrictedInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestSpecificResponseCallback { - void onSuccess(Integer returnValue); + public interface NullableRangeRestrictedInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface ListInt8uAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListOctetStringAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListStructOctetStringAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface VendorIdAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListNullablesAndOptionalsStructAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListLongOctetStringAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBooleanAttributeCallback { - void onSuccess(@Nullable Boolean value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap8AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap16AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap32AttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap64AttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt8uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt16uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt24uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt32uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt40uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt48uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt56uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt64uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt8sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt16sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt24sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt32sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt40sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt48sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt56sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt64sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableEnum8AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableEnum16AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableFloatSingleAttributeCallback { - void onSuccess(@Nullable Float value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableFloatDoubleAttributeCallback { - void onSuccess(@Nullable Double value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableOctetStringAttributeCallback { - void onSuccess(@Nullable byte[] value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableCharStringAttributeCallback { - void onSuccess(@Nullable String value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableEnumAttrAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt8uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt8sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt16uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt16sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readBooleanAttribute(BooleanAttributeCallback callback) { readBooleanAttribute(chipClusterPtr, callback); } + public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap8Attribute( - IntegerAttributeCallback callback - ) { + public void readBitmap8Attribute(IntegerAttributeCallback callback) { readBitmap8Attribute(chipClusterPtr, callback); } + public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value) { writeBitmap8Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeBitmap8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap8Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap16Attribute( - IntegerAttributeCallback callback - ) { + public void readBitmap16Attribute(IntegerAttributeCallback callback) { readBitmap16Attribute(chipClusterPtr, callback); } + public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value) { writeBitmap16Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeBitmap16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap16Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap32Attribute( - LongAttributeCallback callback - ) { + public void readBitmap32Attribute(LongAttributeCallback callback) { readBitmap32Attribute(chipClusterPtr, callback); } + public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value) { writeBitmap32Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBitmap32Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap32Attribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap64Attribute( - LongAttributeCallback callback - ) { + public void readBitmap64Attribute(LongAttributeCallback callback) { readBitmap64Attribute(chipClusterPtr, callback); } + public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value) { writeBitmap64Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBitmap64Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap64Attribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt8uAttribute( - IntegerAttributeCallback callback - ) { + public void readInt8uAttribute(IntegerAttributeCallback callback) { readInt8uAttribute(chipClusterPtr, callback); } + public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt8uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt16uAttribute( - IntegerAttributeCallback callback - ) { + public void readInt16uAttribute(IntegerAttributeCallback callback) { readInt16uAttribute(chipClusterPtr, callback); } + public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt16uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt24uAttribute( - LongAttributeCallback callback - ) { + public void readInt24uAttribute(LongAttributeCallback callback) { readInt24uAttribute(chipClusterPtr, callback); } + public void writeInt24uAttribute(DefaultClusterCallback callback, Long value) { writeInt24uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt24uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt24uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt32uAttribute( - LongAttributeCallback callback - ) { + public void readInt32uAttribute(LongAttributeCallback callback) { readInt32uAttribute(chipClusterPtr, callback); } + public void writeInt32uAttribute(DefaultClusterCallback callback, Long value) { writeInt32uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt32uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt32uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt40uAttribute( - LongAttributeCallback callback - ) { + public void readInt40uAttribute(LongAttributeCallback callback) { readInt40uAttribute(chipClusterPtr, callback); } + public void writeInt40uAttribute(DefaultClusterCallback callback, Long value) { writeInt40uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt40uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt40uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt48uAttribute( - LongAttributeCallback callback - ) { + public void readInt48uAttribute(LongAttributeCallback callback) { readInt48uAttribute(chipClusterPtr, callback); } + public void writeInt48uAttribute(DefaultClusterCallback callback, Long value) { writeInt48uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt48uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt48uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt56uAttribute( - LongAttributeCallback callback - ) { + public void readInt56uAttribute(LongAttributeCallback callback) { readInt56uAttribute(chipClusterPtr, callback); } + public void writeInt56uAttribute(DefaultClusterCallback callback, Long value) { writeInt56uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt56uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt56uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt64uAttribute( - LongAttributeCallback callback - ) { + public void readInt64uAttribute(LongAttributeCallback callback) { readInt64uAttribute(chipClusterPtr, callback); } + public void writeInt64uAttribute(DefaultClusterCallback callback, Long value) { writeInt64uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt64uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt64uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt8sAttribute( - IntegerAttributeCallback callback - ) { + public void readInt8sAttribute(IntegerAttributeCallback callback) { readInt8sAttribute(chipClusterPtr, callback); } + public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt8sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt16sAttribute( - IntegerAttributeCallback callback - ) { + public void readInt16sAttribute(IntegerAttributeCallback callback) { readInt16sAttribute(chipClusterPtr, callback); } + public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt16sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt24sAttribute( - LongAttributeCallback callback - ) { + public void readInt24sAttribute(LongAttributeCallback callback) { readInt24sAttribute(chipClusterPtr, callback); } + public void writeInt24sAttribute(DefaultClusterCallback callback, Long value) { writeInt24sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt24sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt24sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt32sAttribute( - LongAttributeCallback callback - ) { + public void readInt32sAttribute(LongAttributeCallback callback) { readInt32sAttribute(chipClusterPtr, callback); } + public void writeInt32sAttribute(DefaultClusterCallback callback, Long value) { writeInt32sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt32sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt32sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt40sAttribute( - LongAttributeCallback callback - ) { + public void readInt40sAttribute(LongAttributeCallback callback) { readInt40sAttribute(chipClusterPtr, callback); } + public void writeInt40sAttribute(DefaultClusterCallback callback, Long value) { writeInt40sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt40sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt40sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt48sAttribute( - LongAttributeCallback callback - ) { + public void readInt48sAttribute(LongAttributeCallback callback) { readInt48sAttribute(chipClusterPtr, callback); } + public void writeInt48sAttribute(DefaultClusterCallback callback, Long value) { writeInt48sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt48sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt48sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt56sAttribute( - LongAttributeCallback callback - ) { + public void readInt56sAttribute(LongAttributeCallback callback) { readInt56sAttribute(chipClusterPtr, callback); } + public void writeInt56sAttribute(DefaultClusterCallback callback, Long value) { writeInt56sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt56sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt56sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt64sAttribute( - LongAttributeCallback callback - ) { + public void readInt64sAttribute(LongAttributeCallback callback) { readInt64sAttribute(chipClusterPtr, callback); } + public void writeInt64sAttribute(DefaultClusterCallback callback, Long value) { writeInt64sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt64sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt64sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnum8Attribute( - IntegerAttributeCallback callback - ) { + public void readEnum8Attribute(IntegerAttributeCallback callback) { readEnum8Attribute(chipClusterPtr, callback); } + public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value) { writeEnum8Attribute(chipClusterPtr, callback, value, null); } - public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnum8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnum8Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnum16Attribute( - IntegerAttributeCallback callback - ) { + public void readEnum16Attribute(IntegerAttributeCallback callback) { readEnum16Attribute(chipClusterPtr, callback); } + public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value) { writeEnum16Attribute(chipClusterPtr, callback, value, null); } - public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnum16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnum16Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFloatSingleAttribute( - FloatAttributeCallback callback - ) { + public void readFloatSingleAttribute(FloatAttributeCallback callback) { readFloatSingleAttribute(chipClusterPtr, callback); } + public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value) { writeFloatSingleAttribute(chipClusterPtr, callback, value, null); } - public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + public void writeFloatSingleAttribute( + DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { writeFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeFloatSingleAttribute( - FloatAttributeCallback callback -, - int minInterval, int maxInterval) { + FloatAttributeCallback callback, int minInterval, int maxInterval) { subscribeFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFloatDoubleAttribute( - DoubleAttributeCallback callback - ) { + public void readFloatDoubleAttribute(DoubleAttributeCallback callback) { readFloatDoubleAttribute(chipClusterPtr, callback); } + public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { writeFloatDoubleAttribute(chipClusterPtr, callback, value, null); } - public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + public void writeFloatDoubleAttribute( + DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { writeFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeFloatDoubleAttribute( - DoubleAttributeCallback callback -, - int minInterval, int maxInterval) { + DoubleAttributeCallback callback, int minInterval, int maxInterval) { subscribeFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOctetStringAttribute( - OctetStringAttributeCallback callback - ) { + public void readOctetStringAttribute(OctetStringAttributeCallback callback) { readOctetStringAttribute(chipClusterPtr, callback); } + public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeOctetStringAttribute( + DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOctetStringAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListInt8uAttribute( - ListInt8uAttributeCallback callback - ) { + public void readListInt8uAttribute(ListInt8uAttributeCallback callback) { readListInt8uAttribute(chipClusterPtr, callback); } + public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value) { writeListInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListInt8uAttribute( + DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListInt8uAttribute( - ListInt8uAttributeCallback callback - , - int minInterval, int maxInterval) { + ListInt8uAttributeCallback callback, int minInterval, int maxInterval) { subscribeListInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListOctetStringAttribute( - ListOctetStringAttributeCallback callback - ) { + public void readListOctetStringAttribute(ListOctetStringAttributeCallback callback) { readListOctetStringAttribute(chipClusterPtr, callback); } - public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeListOctetStringAttribute( + DefaultClusterCallback callback, ArrayList value) { writeListOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListOctetStringAttribute( + DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListOctetStringAttribute( - ListOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + ListOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeListOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readListStructOctetStringAttribute( - ListStructOctetStringAttributeCallback callback - ) { + ListStructOctetStringAttributeCallback callback) { readListStructOctetStringAttribute(chipClusterPtr, callback); } - public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeListStructOctetStringAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeListStructOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListStructOctetStringAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeListStructOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListStructOctetStringAttribute( - ListStructOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + ListStructOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeListStructOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLongOctetStringAttribute( - OctetStringAttributeCallback callback - ) { + public void readLongOctetStringAttribute(OctetStringAttributeCallback callback) { readLongOctetStringAttribute(chipClusterPtr, callback); } + public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeLongOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeLongOctetStringAttribute( + DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeLongOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLongOctetStringAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCharStringAttribute( - CharStringAttributeCallback callback - ) { + public void readCharStringAttribute(CharStringAttributeCallback callback) { readCharStringAttribute(chipClusterPtr, callback); } + public void writeCharStringAttribute(DefaultClusterCallback callback, String value) { writeCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeCharStringAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeCharStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLongCharStringAttribute( - CharStringAttributeCallback callback - ) { + public void readLongCharStringAttribute(CharStringAttributeCallback callback) { readLongCharStringAttribute(chipClusterPtr, callback); } + public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value) { writeLongCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLongCharStringAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLongCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLongCharStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLongCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEpochUsAttribute( - LongAttributeCallback callback - ) { + public void readEpochUsAttribute(LongAttributeCallback callback) { readEpochUsAttribute(chipClusterPtr, callback); } + public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value) { writeEpochUsAttribute(chipClusterPtr, callback, value, null); } - public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeEpochUsAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeEpochUsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEpochUsAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeEpochUsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEpochSAttribute( - LongAttributeCallback callback - ) { + public void readEpochSAttribute(LongAttributeCallback callback) { readEpochSAttribute(chipClusterPtr, callback); } + public void writeEpochSAttribute(DefaultClusterCallback callback, Long value) { writeEpochSAttribute(chipClusterPtr, callback, value, null); } - public void writeEpochSAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeEpochSAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeEpochSAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEpochSAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeEpochSAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIdAttribute( - VendorIdAttributeCallback callback - ) { + public void readVendorIdAttribute(VendorIdAttributeCallback callback) { readVendorIdAttribute(chipClusterPtr, callback); } + public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value) { writeVendorIdAttribute(chipClusterPtr, callback, value, null); } - public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeVendorIdAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeVendorIdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeVendorIdAttribute( - VendorIdAttributeCallback callback - , - int minInterval, int maxInterval) { + VendorIdAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readListNullablesAndOptionalsStructAttribute( - ListNullablesAndOptionalsStructAttributeCallback callback - ) { + ListNullablesAndOptionalsStructAttributeCallback callback) { readListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback); } - public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeListNullablesAndOptionalsStructAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, null); } - public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { - writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeListNullablesAndOptionalsStructAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { + writeListNullablesAndOptionalsStructAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListNullablesAndOptionalsStructAttribute( - ListNullablesAndOptionalsStructAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, minInterval, maxInterval); + ListNullablesAndOptionalsStructAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeListNullablesAndOptionalsStructAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnumAttrAttribute( - IntegerAttributeCallback callback - ) { + public void readEnumAttrAttribute(IntegerAttributeCallback callback) { readEnumAttrAttribute(chipClusterPtr, callback); } + public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { writeEnumAttrAttribute(chipClusterPtr, callback, value, null); } - public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnumAttrAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnumAttrAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt8uAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt8uAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt8uAttribute(chipClusterPtr, callback); } + public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt8uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt8sAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt8sAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt8sAttribute(chipClusterPtr, callback); } + public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt8sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt16uAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt16uAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt16uAttribute(chipClusterPtr, callback); } - public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt16uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt16sAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt16sAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt16sAttribute(chipClusterPtr, callback); } - public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt16sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListLongOctetStringAttribute( - ListLongOctetStringAttributeCallback callback - ) { + public void readListLongOctetStringAttribute(ListLongOctetStringAttributeCallback callback) { readListLongOctetStringAttribute(chipClusterPtr, callback); } + public void subscribeListLongOctetStringAttribute( - ListLongOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + ListLongOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeListLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTimedWriteBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readTimedWriteBooleanAttribute(BooleanAttributeCallback callback) { readTimedWriteBooleanAttribute(chipClusterPtr, callback); } - public void writeTimedWriteBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeTimedWriteBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeTimedWriteBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeTimedWriteBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeTimedWriteBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGeneralErrorBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readGeneralErrorBooleanAttribute(BooleanAttributeCallback callback) { readGeneralErrorBooleanAttribute(chipClusterPtr, callback); } + public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeGeneralErrorBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeGeneralErrorBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeGeneralErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterErrorBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readClusterErrorBooleanAttribute(BooleanAttributeCallback callback) { readClusterErrorBooleanAttribute(chipClusterPtr, callback); } + public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeClusterErrorBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeClusterErrorBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUnsupportedAttribute( - BooleanAttributeCallback callback - ) { + public void readUnsupportedAttribute(BooleanAttributeCallback callback) { readUnsupportedAttribute(chipClusterPtr, callback); } + public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value) { writeUnsupportedAttribute(chipClusterPtr, callback, value, null); } - public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeUnsupportedAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeUnsupportedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeUnsupportedAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeUnsupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBooleanAttribute( - NullableBooleanAttributeCallback callback - ) { + public void readNullableBooleanAttribute(NullableBooleanAttributeCallback callback) { readNullableBooleanAttribute(chipClusterPtr, callback); } + public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeNullableBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeNullableBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeNullableBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBooleanAttribute( - NullableBooleanAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap8Attribute( - NullableBitmap8AttributeCallback callback - ) { + public void readNullableBitmap8Attribute(NullableBitmap8AttributeCallback callback) { readNullableBitmap8Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value) { writeNullableBitmap8Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableBitmap8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap8Attribute( - NullableBitmap8AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap8AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap16Attribute( - NullableBitmap16AttributeCallback callback - ) { + public void readNullableBitmap16Attribute(NullableBitmap16AttributeCallback callback) { readNullableBitmap16Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value) { writeNullableBitmap16Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableBitmap16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap16Attribute( - NullableBitmap16AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap16AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap32Attribute( - NullableBitmap32AttributeCallback callback - ) { + public void readNullableBitmap32Attribute(NullableBitmap32AttributeCallback callback) { readNullableBitmap32Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value) { writeNullableBitmap32Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableBitmap32Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap32Attribute( - NullableBitmap32AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap32AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap64Attribute( - NullableBitmap64AttributeCallback callback - ) { + public void readNullableBitmap64Attribute(NullableBitmap64AttributeCallback callback) { readNullableBitmap64Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value) { writeNullableBitmap64Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableBitmap64Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap64Attribute( - NullableBitmap64AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap64AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt8uAttribute( - NullableInt8uAttributeCallback callback - ) { + public void readNullableInt8uAttribute(NullableInt8uAttributeCallback callback) { readNullableInt8uAttribute(chipClusterPtr, callback); } + public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt8uAttribute( - NullableInt8uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt8uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt16uAttribute( - NullableInt16uAttributeCallback callback - ) { + public void readNullableInt16uAttribute(NullableInt16uAttributeCallback callback) { readNullableInt16uAttribute(chipClusterPtr, callback); } + public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt16uAttribute( - NullableInt16uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt16uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt24uAttribute( - NullableInt24uAttributeCallback callback - ) { + public void readNullableInt24uAttribute(NullableInt24uAttributeCallback callback) { readNullableInt24uAttribute(chipClusterPtr, callback); } + public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt24uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt24uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt24uAttribute( - NullableInt24uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt24uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt32uAttribute( - NullableInt32uAttributeCallback callback - ) { + public void readNullableInt32uAttribute(NullableInt32uAttributeCallback callback) { readNullableInt32uAttribute(chipClusterPtr, callback); } + public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt32uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt32uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt32uAttribute( - NullableInt32uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt32uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt40uAttribute( - NullableInt40uAttributeCallback callback - ) { + public void readNullableInt40uAttribute(NullableInt40uAttributeCallback callback) { readNullableInt40uAttribute(chipClusterPtr, callback); } + public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt40uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt40uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt40uAttribute( - NullableInt40uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt40uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt48uAttribute( - NullableInt48uAttributeCallback callback - ) { + public void readNullableInt48uAttribute(NullableInt48uAttributeCallback callback) { readNullableInt48uAttribute(chipClusterPtr, callback); } + public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt48uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt48uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt48uAttribute( - NullableInt48uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt48uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt56uAttribute( - NullableInt56uAttributeCallback callback - ) { + public void readNullableInt56uAttribute(NullableInt56uAttributeCallback callback) { readNullableInt56uAttribute(chipClusterPtr, callback); } + public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt56uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt56uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt56uAttribute( - NullableInt56uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt56uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt64uAttribute( - NullableInt64uAttributeCallback callback - ) { + public void readNullableInt64uAttribute(NullableInt64uAttributeCallback callback) { readNullableInt64uAttribute(chipClusterPtr, callback); } + public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt64uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt64uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt64uAttribute( - NullableInt64uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt64uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt8sAttribute( - NullableInt8sAttributeCallback callback - ) { + public void readNullableInt8sAttribute(NullableInt8sAttributeCallback callback) { readNullableInt8sAttribute(chipClusterPtr, callback); } + public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt8sAttribute( - NullableInt8sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt8sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt16sAttribute( - NullableInt16sAttributeCallback callback - ) { + public void readNullableInt16sAttribute(NullableInt16sAttributeCallback callback) { readNullableInt16sAttribute(chipClusterPtr, callback); } + public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt16sAttribute( - NullableInt16sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt16sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt24sAttribute( - NullableInt24sAttributeCallback callback - ) { + public void readNullableInt24sAttribute(NullableInt24sAttributeCallback callback) { readNullableInt24sAttribute(chipClusterPtr, callback); } + public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt24sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt24sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt24sAttribute( - NullableInt24sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt24sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt32sAttribute( - NullableInt32sAttributeCallback callback - ) { + public void readNullableInt32sAttribute(NullableInt32sAttributeCallback callback) { readNullableInt32sAttribute(chipClusterPtr, callback); } + public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt32sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt32sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt32sAttribute( - NullableInt32sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt32sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt40sAttribute( - NullableInt40sAttributeCallback callback - ) { + public void readNullableInt40sAttribute(NullableInt40sAttributeCallback callback) { readNullableInt40sAttribute(chipClusterPtr, callback); } + public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt40sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt40sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt40sAttribute( - NullableInt40sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt40sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt48sAttribute( - NullableInt48sAttributeCallback callback - ) { + public void readNullableInt48sAttribute(NullableInt48sAttributeCallback callback) { readNullableInt48sAttribute(chipClusterPtr, callback); } + public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt48sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt48sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt48sAttribute( - NullableInt48sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt48sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt56sAttribute( - NullableInt56sAttributeCallback callback - ) { + public void readNullableInt56sAttribute(NullableInt56sAttributeCallback callback) { readNullableInt56sAttribute(chipClusterPtr, callback); } + public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt56sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt56sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt56sAttribute( - NullableInt56sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt56sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt64sAttribute( - NullableInt64sAttributeCallback callback - ) { + public void readNullableInt64sAttribute(NullableInt64sAttributeCallback callback) { readNullableInt64sAttribute(chipClusterPtr, callback); } + public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt64sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt64sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt64sAttribute( - NullableInt64sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt64sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnum8Attribute( - NullableEnum8AttributeCallback callback - ) { + public void readNullableEnum8Attribute(NullableEnum8AttributeCallback callback) { readNullableEnum8Attribute(chipClusterPtr, callback); } + public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value) { writeNullableEnum8Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnum8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableEnum8Attribute( - NullableEnum8AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableEnum8AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnum16Attribute( - NullableEnum16AttributeCallback callback - ) { + public void readNullableEnum16Attribute(NullableEnum16AttributeCallback callback) { readNullableEnum16Attribute(chipClusterPtr, callback); } + public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value) { writeNullableEnum16Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnum16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableEnum16Attribute( - NullableEnum16AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableEnum16AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableFloatSingleAttribute( - NullableFloatSingleAttributeCallback callback - ) { + public void readNullableFloatSingleAttribute(NullableFloatSingleAttributeCallback callback) { readNullableFloatSingleAttribute(chipClusterPtr, callback); } + public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value) { writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + public void writeNullableFloatSingleAttribute( + DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableFloatSingleAttribute( - NullableFloatSingleAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableFloatSingleAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableFloatDoubleAttribute( - NullableFloatDoubleAttributeCallback callback - ) { + public void readNullableFloatDoubleAttribute(NullableFloatDoubleAttributeCallback callback) { readNullableFloatDoubleAttribute(chipClusterPtr, callback); } + public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + public void writeNullableFloatDoubleAttribute( + DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableFloatDoubleAttribute( - NullableFloatDoubleAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableFloatDoubleAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableOctetStringAttribute( - NullableOctetStringAttributeCallback callback - ) { + public void readNullableOctetStringAttribute(NullableOctetStringAttributeCallback callback) { readNullableOctetStringAttribute(chipClusterPtr, callback); } + public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeNullableOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeNullableOctetStringAttribute( + DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeNullableOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableOctetStringAttribute( - NullableOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableCharStringAttribute( - NullableCharStringAttributeCallback callback - ) { + public void readNullableCharStringAttribute(NullableCharStringAttributeCallback callback) { readNullableCharStringAttribute(chipClusterPtr, callback); } + public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value) { writeNullableCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeNullableCharStringAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeNullableCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableCharStringAttribute( - NullableCharStringAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableCharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnumAttrAttribute( - NullableEnumAttrAttributeCallback callback - ) { + public void readNullableEnumAttrAttribute(NullableEnumAttrAttributeCallback callback) { readNullableEnumAttrAttribute(chipClusterPtr, callback); } + public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnumAttrAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableEnumAttrAttribute( - NullableEnumAttrAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableEnumAttrAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt8uAttribute( - NullableRangeRestrictedInt8uAttributeCallback callback - ) { + NullableRangeRestrictedInt8uAttributeCallback callback) { readNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8uAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt8uAttribute( - NullableRangeRestrictedInt8uAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt8uAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8uAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt8sAttribute( - NullableRangeRestrictedInt8sAttributeCallback callback - ) { + NullableRangeRestrictedInt8sAttributeCallback callback) { readNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8sAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt8sAttribute( - NullableRangeRestrictedInt8sAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt8sAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8sAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt16uAttribute( - NullableRangeRestrictedInt16uAttributeCallback callback - ) { + NullableRangeRestrictedInt16uAttributeCallback callback) { readNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16uAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt16uAttribute( - NullableRangeRestrictedInt16uAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt16uAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16uAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt16sAttribute( - NullableRangeRestrictedInt16sAttributeCallback callback - ) { + NullableRangeRestrictedInt16sAttributeCallback callback) { readNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16sAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt16sAttribute( - NullableRangeRestrictedInt16sAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt16sAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16sAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap32Attribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap32Attribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap64Attribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap64Attribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt24uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt24uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt32uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt32uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt40uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt40uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt48uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt48uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt56uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt56uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt64uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt64uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt24sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt24sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt32sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt32sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt40sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt40sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt48sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt48sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt56sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt56sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt64sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt64sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnum8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnum8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnum16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnum16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readFloatSingleAttribute(long chipClusterPtr, - FloatAttributeCallback callback - ); - - private native void writeFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeFloatSingleAttribute(long chipClusterPtr, - FloatAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readFloatDoubleAttribute(long chipClusterPtr, - DoubleAttributeCallback callback - ); - - private native void writeFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeFloatDoubleAttribute(long chipClusterPtr, - DoubleAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - - private native void writeOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readListInt8uAttribute(long chipClusterPtr, - ListInt8uAttributeCallback callback - ); - - private native void writeListInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListInt8uAttribute(long chipClusterPtr, - ListInt8uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readListOctetStringAttribute(long chipClusterPtr, - ListOctetStringAttributeCallback callback - ); - - private native void writeListOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListOctetStringAttribute(long chipClusterPtr, - ListOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readListStructOctetStringAttribute(long chipClusterPtr, - ListStructOctetStringAttributeCallback callback - ); - - private native void writeListStructOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListStructOctetStringAttribute(long chipClusterPtr, - ListStructOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readLongOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - - private native void writeLongOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLongOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLongCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeLongCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLongCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEpochUsAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeEpochUsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEpochUsAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEpochSAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeEpochSAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEpochSAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorIdAttribute(long chipClusterPtr, - VendorIdAttributeCallback callback - ); - - private native void writeVendorIdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeVendorIdAttribute(long chipClusterPtr, - VendorIdAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readListNullablesAndOptionalsStructAttribute(long chipClusterPtr, - ListNullablesAndOptionalsStructAttributeCallback callback - ); - - private native void writeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, - ListNullablesAndOptionalsStructAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readEnumAttrAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnumAttrAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readListLongOctetStringAttribute(long chipClusterPtr, - ListLongOctetStringAttributeCallback callback - ); - private native void subscribeListLongOctetStringAttribute(long chipClusterPtr, - ListLongOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readTimedWriteBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeTimedWriteBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeTimedWriteBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readGeneralErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeGeneralErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeGeneralErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readClusterErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeClusterErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeClusterErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUnsupportedAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeUnsupportedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeUnsupportedAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNullableBooleanAttribute(long chipClusterPtr, - NullableBooleanAttributeCallback callback - ); - - private native void writeNullableBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBooleanAttribute(long chipClusterPtr, - NullableBooleanAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap8Attribute(long chipClusterPtr, - NullableBitmap8AttributeCallback callback - ); - - private native void writeNullableBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap8Attribute(long chipClusterPtr, - NullableBitmap8AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap16Attribute(long chipClusterPtr, - NullableBitmap16AttributeCallback callback - ); - - private native void writeNullableBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap16Attribute(long chipClusterPtr, - NullableBitmap16AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap32Attribute(long chipClusterPtr, - NullableBitmap32AttributeCallback callback - ); - - private native void writeNullableBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap32Attribute(long chipClusterPtr, - NullableBitmap32AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap64Attribute(long chipClusterPtr, - NullableBitmap64AttributeCallback callback - ); - - private native void writeNullableBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap64Attribute(long chipClusterPtr, - NullableBitmap64AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt8uAttribute(long chipClusterPtr, - NullableInt8uAttributeCallback callback - ); - - private native void writeNullableInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt8uAttribute(long chipClusterPtr, - NullableInt8uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt16uAttribute(long chipClusterPtr, - NullableInt16uAttributeCallback callback - ); - - private native void writeNullableInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt16uAttribute(long chipClusterPtr, - NullableInt16uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt24uAttribute(long chipClusterPtr, - NullableInt24uAttributeCallback callback - ); - - private native void writeNullableInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt24uAttribute(long chipClusterPtr, - NullableInt24uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt32uAttribute(long chipClusterPtr, - NullableInt32uAttributeCallback callback - ); - - private native void writeNullableInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt32uAttribute(long chipClusterPtr, - NullableInt32uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt40uAttribute(long chipClusterPtr, - NullableInt40uAttributeCallback callback - ); - - private native void writeNullableInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt40uAttribute(long chipClusterPtr, - NullableInt40uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt48uAttribute(long chipClusterPtr, - NullableInt48uAttributeCallback callback - ); - - private native void writeNullableInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt48uAttribute(long chipClusterPtr, - NullableInt48uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt56uAttribute(long chipClusterPtr, - NullableInt56uAttributeCallback callback - ); - - private native void writeNullableInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt56uAttribute(long chipClusterPtr, - NullableInt56uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt64uAttribute(long chipClusterPtr, - NullableInt64uAttributeCallback callback - ); - - private native void writeNullableInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt64uAttribute(long chipClusterPtr, - NullableInt64uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt8sAttribute(long chipClusterPtr, - NullableInt8sAttributeCallback callback - ); - - private native void writeNullableInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt8sAttribute(long chipClusterPtr, - NullableInt8sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt16sAttribute(long chipClusterPtr, - NullableInt16sAttributeCallback callback - ); - - private native void writeNullableInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt16sAttribute(long chipClusterPtr, - NullableInt16sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt24sAttribute(long chipClusterPtr, - NullableInt24sAttributeCallback callback - ); - - private native void writeNullableInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt24sAttribute(long chipClusterPtr, - NullableInt24sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt32sAttribute(long chipClusterPtr, - NullableInt32sAttributeCallback callback - ); - - private native void writeNullableInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt32sAttribute(long chipClusterPtr, - NullableInt32sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt40sAttribute(long chipClusterPtr, - NullableInt40sAttributeCallback callback - ); - - private native void writeNullableInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt40sAttribute(long chipClusterPtr, - NullableInt40sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt48sAttribute(long chipClusterPtr, - NullableInt48sAttributeCallback callback - ); - - private native void writeNullableInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt48sAttribute(long chipClusterPtr, - NullableInt48sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt56sAttribute(long chipClusterPtr, - NullableInt56sAttributeCallback callback - ); - - private native void writeNullableInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt56sAttribute(long chipClusterPtr, - NullableInt56sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt64sAttribute(long chipClusterPtr, - NullableInt64sAttributeCallback callback - ); - - private native void writeNullableInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt64sAttribute(long chipClusterPtr, - NullableInt64sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableEnum8Attribute(long chipClusterPtr, - NullableEnum8AttributeCallback callback - ); - - private native void writeNullableEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableEnum8Attribute(long chipClusterPtr, - NullableEnum8AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableEnum16Attribute(long chipClusterPtr, - NullableEnum16AttributeCallback callback - ); - - private native void writeNullableEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableEnum16Attribute(long chipClusterPtr, - NullableEnum16AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableFloatSingleAttribute(long chipClusterPtr, - NullableFloatSingleAttributeCallback callback - ); - - private native void writeNullableFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableFloatSingleAttribute(long chipClusterPtr, - NullableFloatSingleAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableFloatDoubleAttribute(long chipClusterPtr, - NullableFloatDoubleAttributeCallback callback - ); - - private native void writeNullableFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableFloatDoubleAttribute(long chipClusterPtr, - NullableFloatDoubleAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableOctetStringAttribute(long chipClusterPtr, - NullableOctetStringAttributeCallback callback - ); - - private native void writeNullableOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableOctetStringAttribute(long chipClusterPtr, - NullableOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableCharStringAttribute(long chipClusterPtr, - NullableCharStringAttributeCallback callback - ); - - private native void writeNullableCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableCharStringAttribute(long chipClusterPtr, - NullableCharStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableEnumAttrAttribute(long chipClusterPtr, - NullableEnumAttrAttributeCallback callback - ); - - private native void writeNullableEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableEnumAttrAttribute(long chipClusterPtr, - NullableEnumAttrAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8uAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8sAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16uAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16sAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16sAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap8Attribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeBitmap8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap8Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap16Attribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeBitmap16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap16Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap32Attribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeBitmap32Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap32Attribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap64Attribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeBitmap64Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap64Attribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt8uAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt16uAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt24uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt24uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt24uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt32uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt32uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt32uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt40uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt40uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt40uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt48uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt48uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt48uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt56uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt56uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt56uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt64uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt64uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt64uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt8sAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt16sAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt24sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt24sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt24sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt32sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt32sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt32sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt40sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt40sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt40sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt48sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt48sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt48sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt56sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt56sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt56sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt64sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt64sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt64sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnum8Attribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeEnum8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnum8Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnum16Attribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeEnum16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnum16Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFloatSingleAttribute( + long chipClusterPtr, FloatAttributeCallback callback); + + private native void writeFloatSingleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Float value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeFloatSingleAttribute( + long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFloatDoubleAttribute( + long chipClusterPtr, DoubleAttributeCallback callback); + + private native void writeFloatDoubleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Double value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeFloatDoubleAttribute( + long chipClusterPtr, DoubleAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOctetStringAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void writeOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + byte[] value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOctetStringAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readListInt8uAttribute( + long chipClusterPtr, ListInt8uAttributeCallback callback); + + private native void writeListInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListInt8uAttribute( + long chipClusterPtr, ListInt8uAttributeCallback callback, int minInterval, int maxInterval); + + private native void readListOctetStringAttribute( + long chipClusterPtr, ListOctetStringAttributeCallback callback); + + private native void writeListOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListOctetStringAttribute( + long chipClusterPtr, + ListOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readListStructOctetStringAttribute( + long chipClusterPtr, ListStructOctetStringAttributeCallback callback); + + private native void writeListStructOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListStructOctetStringAttribute( + long chipClusterPtr, + ListStructOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLongOctetStringAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void writeLongOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + byte[] value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLongOctetStringAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCharStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeCharStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeCharStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLongCharStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeLongCharStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLongCharStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEpochUsAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeEpochUsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEpochUsAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEpochSAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeEpochSAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEpochSAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readVendorIdAttribute( + long chipClusterPtr, VendorIdAttributeCallback callback); + + private native void writeVendorIdAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeVendorIdAttribute( + long chipClusterPtr, VendorIdAttributeCallback callback, int minInterval, int maxInterval); + + private native void readListNullablesAndOptionalsStructAttribute( + long chipClusterPtr, ListNullablesAndOptionalsStructAttributeCallback callback); + + private native void writeListNullablesAndOptionalsStructAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListNullablesAndOptionalsStructAttribute( + long chipClusterPtr, + ListNullablesAndOptionalsStructAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEnumAttrAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeEnumAttrAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnumAttrAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readListLongOctetStringAttribute( + long chipClusterPtr, ListLongOctetStringAttributeCallback callback); + + private native void subscribeListLongOctetStringAttribute( + long chipClusterPtr, + ListLongOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readTimedWriteBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeTimedWriteBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeTimedWriteBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readGeneralErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeGeneralErrorBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeGeneralErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readClusterErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeClusterErrorBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeClusterErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUnsupportedAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeUnsupportedAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeUnsupportedAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNullableBooleanAttribute( + long chipClusterPtr, NullableBooleanAttributeCallback callback); + + private native void writeNullableBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBooleanAttribute( + long chipClusterPtr, + NullableBooleanAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap8Attribute( + long chipClusterPtr, NullableBitmap8AttributeCallback callback); + + private native void writeNullableBitmap8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap8Attribute( + long chipClusterPtr, + NullableBitmap8AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap16Attribute( + long chipClusterPtr, NullableBitmap16AttributeCallback callback); + + private native void writeNullableBitmap16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap16Attribute( + long chipClusterPtr, + NullableBitmap16AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap32Attribute( + long chipClusterPtr, NullableBitmap32AttributeCallback callback); + + private native void writeNullableBitmap32Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap32Attribute( + long chipClusterPtr, + NullableBitmap32AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap64Attribute( + long chipClusterPtr, NullableBitmap64AttributeCallback callback); + + private native void writeNullableBitmap64Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap64Attribute( + long chipClusterPtr, + NullableBitmap64AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt8uAttribute( + long chipClusterPtr, NullableInt8uAttributeCallback callback); + + private native void writeNullableInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt8uAttribute( + long chipClusterPtr, + NullableInt8uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt16uAttribute( + long chipClusterPtr, NullableInt16uAttributeCallback callback); + + private native void writeNullableInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt16uAttribute( + long chipClusterPtr, + NullableInt16uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt24uAttribute( + long chipClusterPtr, NullableInt24uAttributeCallback callback); + + private native void writeNullableInt24uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt24uAttribute( + long chipClusterPtr, + NullableInt24uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt32uAttribute( + long chipClusterPtr, NullableInt32uAttributeCallback callback); + + private native void writeNullableInt32uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt32uAttribute( + long chipClusterPtr, + NullableInt32uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt40uAttribute( + long chipClusterPtr, NullableInt40uAttributeCallback callback); + + private native void writeNullableInt40uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt40uAttribute( + long chipClusterPtr, + NullableInt40uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt48uAttribute( + long chipClusterPtr, NullableInt48uAttributeCallback callback); + + private native void writeNullableInt48uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt48uAttribute( + long chipClusterPtr, + NullableInt48uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt56uAttribute( + long chipClusterPtr, NullableInt56uAttributeCallback callback); + + private native void writeNullableInt56uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt56uAttribute( + long chipClusterPtr, + NullableInt56uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt64uAttribute( + long chipClusterPtr, NullableInt64uAttributeCallback callback); + + private native void writeNullableInt64uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt64uAttribute( + long chipClusterPtr, + NullableInt64uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt8sAttribute( + long chipClusterPtr, NullableInt8sAttributeCallback callback); + + private native void writeNullableInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt8sAttribute( + long chipClusterPtr, + NullableInt8sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt16sAttribute( + long chipClusterPtr, NullableInt16sAttributeCallback callback); + + private native void writeNullableInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt16sAttribute( + long chipClusterPtr, + NullableInt16sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt24sAttribute( + long chipClusterPtr, NullableInt24sAttributeCallback callback); + + private native void writeNullableInt24sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt24sAttribute( + long chipClusterPtr, + NullableInt24sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt32sAttribute( + long chipClusterPtr, NullableInt32sAttributeCallback callback); + + private native void writeNullableInt32sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt32sAttribute( + long chipClusterPtr, + NullableInt32sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt40sAttribute( + long chipClusterPtr, NullableInt40sAttributeCallback callback); + + private native void writeNullableInt40sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt40sAttribute( + long chipClusterPtr, + NullableInt40sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt48sAttribute( + long chipClusterPtr, NullableInt48sAttributeCallback callback); + + private native void writeNullableInt48sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt48sAttribute( + long chipClusterPtr, + NullableInt48sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt56sAttribute( + long chipClusterPtr, NullableInt56sAttributeCallback callback); + + private native void writeNullableInt56sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt56sAttribute( + long chipClusterPtr, + NullableInt56sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt64sAttribute( + long chipClusterPtr, NullableInt64sAttributeCallback callback); + + private native void writeNullableInt64sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt64sAttribute( + long chipClusterPtr, + NullableInt64sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableEnum8Attribute( + long chipClusterPtr, NullableEnum8AttributeCallback callback); + + private native void writeNullableEnum8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableEnum8Attribute( + long chipClusterPtr, + NullableEnum8AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableEnum16Attribute( + long chipClusterPtr, NullableEnum16AttributeCallback callback); + + private native void writeNullableEnum16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableEnum16Attribute( + long chipClusterPtr, + NullableEnum16AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableFloatSingleAttribute( + long chipClusterPtr, NullableFloatSingleAttributeCallback callback); + + private native void writeNullableFloatSingleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Float value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableFloatSingleAttribute( + long chipClusterPtr, + NullableFloatSingleAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableFloatDoubleAttribute( + long chipClusterPtr, NullableFloatDoubleAttributeCallback callback); + + private native void writeNullableFloatDoubleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Double value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableFloatDoubleAttribute( + long chipClusterPtr, + NullableFloatDoubleAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableOctetStringAttribute( + long chipClusterPtr, NullableOctetStringAttributeCallback callback); + + private native void writeNullableOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + byte[] value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableOctetStringAttribute( + long chipClusterPtr, + NullableOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableCharStringAttribute( + long chipClusterPtr, NullableCharStringAttributeCallback callback); + + private native void writeNullableCharStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableCharStringAttribute( + long chipClusterPtr, + NullableCharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableEnumAttrAttribute( + long chipClusterPtr, NullableEnumAttrAttributeCallback callback); + + private native void writeNullableEnumAttrAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableEnumAttrAttribute( + long chipClusterPtr, + NullableEnumAttrAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, NullableRangeRestrictedInt8uAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt8uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, NullableRangeRestrictedInt8sAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt8sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, NullableRangeRestrictedInt16uAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt16uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, NullableRangeRestrictedInt16sAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt16sAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ThermostatCluster extends BaseChipCluster { @@ -14214,554 +15440,587 @@ public ThermostatCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void clearWeeklySchedule(DefaultClusterCallback callback - ) { + public void clearWeeklySchedule(DefaultClusterCallback callback) { clearWeeklySchedule(chipClusterPtr, callback, null); } - public void clearWeeklySchedule(DefaultClusterCallback callback + public void clearWeeklySchedule(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { clearWeeklySchedule(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback - ) { + public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback) { getRelayStatusLog(chipClusterPtr, callback, null); } - public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback + public void getRelayStatusLog( + GetRelayStatusLogResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { getRelayStatusLog(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback - , Integer daysToReturn, Integer modeToReturn) { + public void getWeeklySchedule( + GetWeeklyScheduleResponseCallback callback, Integer daysToReturn, Integer modeToReturn) { getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, null); } - public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback - , Integer daysToReturn, Integer modeToReturn - , int timedInvokeTimeoutMs) { + public void getWeeklySchedule( + GetWeeklyScheduleResponseCallback callback, + Integer daysToReturn, + Integer modeToReturn, + int timedInvokeTimeoutMs) { getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, timedInvokeTimeoutMs); } - public void setWeeklySchedule(DefaultClusterCallback callback - , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload) { - setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, payload, null); - } - - public void setWeeklySchedule(DefaultClusterCallback callback - , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload - , int timedInvokeTimeoutMs) { - setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, payload, timedInvokeTimeoutMs); - } - - public void setpointRaiseLower(DefaultClusterCallback callback - , Integer mode, Integer amount) { + public void setWeeklySchedule( + DefaultClusterCallback callback, + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload) { + setWeeklySchedule( + chipClusterPtr, + callback, + numberOfTransitionsForSequence, + dayOfWeekForSequence, + modeForSequence, + payload, + null); + } + + public void setWeeklySchedule( + DefaultClusterCallback callback, + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload, + int timedInvokeTimeoutMs) { + setWeeklySchedule( + chipClusterPtr, + callback, + numberOfTransitionsForSequence, + dayOfWeekForSequence, + modeForSequence, + payload, + timedInvokeTimeoutMs); + } + + public void setpointRaiseLower(DefaultClusterCallback callback, Integer mode, Integer amount) { setpointRaiseLower(chipClusterPtr, callback, mode, amount, null); } - public void setpointRaiseLower(DefaultClusterCallback callback - , Integer mode, Integer amount - , int timedInvokeTimeoutMs) { + public void setpointRaiseLower( + DefaultClusterCallback callback, Integer mode, Integer amount, int timedInvokeTimeoutMs) { setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs); } - private native void clearWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void getRelayStatusLog(long chipClusterPtr, GetRelayStatusLogResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void getWeeklySchedule(long chipClusterPtr, GetWeeklyScheduleResponseCallback Callback - , Integer daysToReturn, Integer modeToReturn - , @Nullable Integer timedInvokeTimeoutMs); - private native void setWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload - , @Nullable Integer timedInvokeTimeoutMs); - private native void setpointRaiseLower(long chipClusterPtr, DefaultClusterCallback Callback - , Integer mode, Integer amount - , @Nullable Integer timedInvokeTimeoutMs); + + private native void clearWeeklySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getRelayStatusLog( + long chipClusterPtr, + GetRelayStatusLogResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getWeeklySchedule( + long chipClusterPtr, + GetWeeklyScheduleResponseCallback Callback, + Integer daysToReturn, + Integer modeToReturn, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setWeeklySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setpointRaiseLower( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer mode, + Integer amount, + @Nullable Integer timedInvokeTimeoutMs); + public interface GetRelayStatusLogResponseCallback { - void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries); + void onSuccess( + Integer timeOfDay, + Integer relayStatus, + Integer localTemperature, + Integer humidityInPercentage, + Integer setpoint, + Integer unreadEntries); void onError(Exception error); } public interface GetWeeklyScheduleResponseCallback { - void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload); + void onSuccess( + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readLocalTemperatureAttribute( - IntegerAttributeCallback callback - ) { + public void readLocalTemperatureAttribute(IntegerAttributeCallback callback) { readLocalTemperatureAttribute(chipClusterPtr, callback); } + public void subscribeLocalTemperatureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocalTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMinHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMaxHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMinCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMaxCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupiedCoolingSetpointAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupiedCoolingSetpointAttribute(IntegerAttributeCallback callback) { readOccupiedCoolingSetpointAttribute(chipClusterPtr, callback); } - public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeOccupiedCoolingSetpointAttribute( + DefaultClusterCallback callback, Integer value) { writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, null); } - public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOccupiedCoolingSetpointAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOccupiedCoolingSetpointAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupiedHeatingSetpointAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupiedHeatingSetpointAttribute(IntegerAttributeCallback callback) { readOccupiedHeatingSetpointAttribute(chipClusterPtr, callback); } - public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeOccupiedHeatingSetpointAttribute( + DefaultClusterCallback callback, Integer value) { writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, null); } - public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOccupiedHeatingSetpointAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOccupiedHeatingSetpointAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMinHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readMinHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinHeatSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMaxHeatSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMinCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readMinCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinCoolSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMaxCoolSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinSetpointDeadBandAttribute( - IntegerAttributeCallback callback - ) { + public void readMinSetpointDeadBandAttribute(IntegerAttributeCallback callback) { readMinSetpointDeadBandAttribute(chipClusterPtr, callback); } + public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value) { writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, null); } - public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinSetpointDeadBandAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMinSetpointDeadBandAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinSetpointDeadBandAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readControlSequenceOfOperationAttribute( - IntegerAttributeCallback callback - ) { + public void readControlSequenceOfOperationAttribute(IntegerAttributeCallback callback) { readControlSequenceOfOperationAttribute(chipClusterPtr, callback); } - public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeControlSequenceOfOperationAttribute( + DefaultClusterCallback callback, Integer value) { writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, null); } - public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeControlSequenceOfOperationAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeControlSequenceOfOperationAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeControlSequenceOfOperationAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeControlSequenceOfOperationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeControlSequenceOfOperationAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readSystemModeAttribute( - IntegerAttributeCallback callback - ) { + public void readSystemModeAttribute(IntegerAttributeCallback callback) { readSystemModeAttribute(chipClusterPtr, callback); } + public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value) { writeSystemModeAttribute(chipClusterPtr, callback, value, null); } - public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSystemModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSystemModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeSystemModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSystemModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartOfWeekAttribute( - IntegerAttributeCallback callback - ) { + public void readStartOfWeekAttribute(IntegerAttributeCallback callback) { readStartOfWeekAttribute(chipClusterPtr, callback); } + public void subscribeStartOfWeekAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartOfWeekAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfWeeklyTransitionsAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfWeeklyTransitionsAttribute(IntegerAttributeCallback callback) { readNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfWeeklyTransitionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfWeeklyTransitionsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfDailyTransitionsAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfDailyTransitionsAttribute(IntegerAttributeCallback callback) { readNumberOfDailyTransitionsAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfDailyTransitionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfDailyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfDailyTransitionsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLocalTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLocalTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupiedCoolingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOccupiedCoolingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOccupiedCoolingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupiedHeatingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOccupiedHeatingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOccupiedHeatingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMinHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMaxHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMinCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMaxCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinSetpointDeadBandAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMinSetpointDeadBandAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMinSetpointDeadBandAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readControlSequenceOfOperationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeControlSequenceOfOperationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeControlSequenceOfOperationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSystemModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeSystemModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSystemModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartOfWeekAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStartOfWeekAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfDailyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfDailyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readLocalTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLocalTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupiedCoolingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOccupiedCoolingSetpointAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOccupiedCoolingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupiedHeatingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOccupiedHeatingSetpointAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOccupiedHeatingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMinHeatSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMaxHeatSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMinCoolSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMaxCoolSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinSetpointDeadBandAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMinSetpointDeadBandAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMinSetpointDeadBandAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readControlSequenceOfOperationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeControlSequenceOfOperationAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeControlSequenceOfOperationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSystemModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeSystemModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSystemModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartOfWeekAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStartOfWeekAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfWeeklyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfWeeklyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfDailyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfDailyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 ThermostatUserInterfaceConfigurationCluster extends BaseChipCluster { @@ -14774,1443 +16033,1237 @@ public ThermostatUserInterfaceConfigurationCluster(long devicePtr, int endpointI @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readTemperatureDisplayModeAttribute( - IntegerAttributeCallback callback - ) { + public void readTemperatureDisplayModeAttribute(IntegerAttributeCallback callback) { readTemperatureDisplayModeAttribute(chipClusterPtr, callback); } - public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeTemperatureDisplayModeAttribute( + DefaultClusterCallback callback, Integer value) { writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, null); } - public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeTemperatureDisplayModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeTemperatureDisplayModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeTemperatureDisplayModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readKeypadLockoutAttribute( - IntegerAttributeCallback callback - ) { + public void readKeypadLockoutAttribute(IntegerAttributeCallback callback) { readKeypadLockoutAttribute(chipClusterPtr, callback); } + public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value) { writeKeypadLockoutAttribute(chipClusterPtr, callback, value, null); } - public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeKeypadLockoutAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeKeypadLockoutAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeKeypadLockoutAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeKeypadLockoutAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readScheduleProgrammingVisibilityAttribute( - IntegerAttributeCallback callback - ) { + public void readScheduleProgrammingVisibilityAttribute(IntegerAttributeCallback callback) { readScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback); } - public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeScheduleProgrammingVisibilityAttribute( + DefaultClusterCallback callback, Integer value) { writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, null); } - public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeScheduleProgrammingVisibilityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeScheduleProgrammingVisibilityAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeScheduleProgrammingVisibilityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeScheduleProgrammingVisibilityAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { - readClusterRevisionAttribute(chipClusterPtr, callback); + 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 readTemperatureDisplayModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeTemperatureDisplayModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeTemperatureDisplayModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readKeypadLockoutAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeKeypadLockoutAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeKeypadLockoutAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readScheduleProgrammingVisibilityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeScheduleProgrammingVisibilityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeScheduleProgrammingVisibilityAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 53L; + + public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void resetCounts(DefaultClusterCallback callback) { + resetCounts(chipClusterPtr, callback, null); + } + + public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + private native void resetCounts( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface NeighborTableListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + + public interface RouteTableListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void readTemperatureDisplayModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeTemperatureDisplayModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeTemperatureDisplayModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readKeypadLockoutAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeKeypadLockoutAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeKeypadLockoutAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readScheduleProgrammingVisibilityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + public interface SecurityPolicyAttributeCallback { + void onSuccess(List valueList); - public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 53L; + void onError(Exception ex); - public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); + default void onSubscriptionEstablished() {} } - @Override - public native long initWithDevice(long devicePtr, int endpointId); + public interface OperationalDatasetComponentsAttributeCallback { + void onSuccess( + List valueList); - public void resetCounts(DefaultClusterCallback callback - ) { - resetCounts(chipClusterPtr, callback, null); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void resetCounts(DefaultClusterCallback callback + public interface ActiveNetworkFaultsListAttributeCallback { + void onSuccess(List valueList); - , int timedInvokeTimeoutMs) { - resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface NeighborTableListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface RouteTableListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface SecurityPolicyAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface OperationalDatasetComponentsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveNetworkFaultsListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readChannelAttribute( - IntegerAttributeCallback callback - ) { + public void readChannelAttribute(IntegerAttributeCallback callback) { readChannelAttribute(chipClusterPtr, callback); } + public void subscribeChannelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeChannelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRoutingRoleAttribute( - IntegerAttributeCallback callback - ) { + public void readRoutingRoleAttribute(IntegerAttributeCallback callback) { readRoutingRoleAttribute(chipClusterPtr, callback); } + public void subscribeRoutingRoleAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRoutingRoleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNetworkNameAttribute( - CharStringAttributeCallback callback - ) { + public void readNetworkNameAttribute(CharStringAttributeCallback callback) { readNetworkNameAttribute(chipClusterPtr, callback); } + public void subscribeNetworkNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNetworkNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPanIdAttribute( - IntegerAttributeCallback callback - ) { + public void readPanIdAttribute(IntegerAttributeCallback callback) { readPanIdAttribute(chipClusterPtr, callback); } + public void subscribePanIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readExtendedPanIdAttribute( - LongAttributeCallback callback - ) { + public void readExtendedPanIdAttribute(LongAttributeCallback callback) { readExtendedPanIdAttribute(chipClusterPtr, callback); } + public void subscribeExtendedPanIdAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeExtendedPanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMeshLocalPrefixAttribute( - OctetStringAttributeCallback callback - ) { + public void readMeshLocalPrefixAttribute(OctetStringAttributeCallback callback) { readMeshLocalPrefixAttribute(chipClusterPtr, callback); } + public void subscribeMeshLocalPrefixAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeshLocalPrefixAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute( - LongAttributeCallback callback - ) { + public void readOverrunCountAttribute(LongAttributeCallback callback) { readOverrunCountAttribute(chipClusterPtr, callback); } + public void subscribeOverrunCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNeighborTableListAttribute( - NeighborTableListAttributeCallback callback - ) { + public void readNeighborTableListAttribute(NeighborTableListAttributeCallback callback) { readNeighborTableListAttribute(chipClusterPtr, callback); } + public void subscribeNeighborTableListAttribute( - NeighborTableListAttributeCallback callback - , - int minInterval, int maxInterval) { + NeighborTableListAttributeCallback callback, int minInterval, int maxInterval) { subscribeNeighborTableListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRouteTableListAttribute( - RouteTableListAttributeCallback callback - ) { + public void readRouteTableListAttribute(RouteTableListAttributeCallback callback) { readRouteTableListAttribute(chipClusterPtr, callback); } + public void subscribeRouteTableListAttribute( - RouteTableListAttributeCallback callback - , - int minInterval, int maxInterval) { + RouteTableListAttributeCallback callback, int minInterval, int maxInterval) { subscribeRouteTableListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartitionIdAttribute( - LongAttributeCallback callback - ) { + public void readPartitionIdAttribute(LongAttributeCallback callback) { readPartitionIdAttribute(chipClusterPtr, callback); } + public void subscribePartitionIdAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePartitionIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWeightingAttribute( - IntegerAttributeCallback callback - ) { + public void readWeightingAttribute(IntegerAttributeCallback callback) { readWeightingAttribute(chipClusterPtr, callback); } + public void subscribeWeightingAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWeightingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDataVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readDataVersionAttribute(IntegerAttributeCallback callback) { readDataVersionAttribute(chipClusterPtr, callback); } + public void subscribeDataVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStableDataVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readStableDataVersionAttribute(IntegerAttributeCallback callback) { readStableDataVersionAttribute(chipClusterPtr, callback); } + public void subscribeStableDataVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStableDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLeaderRouterIdAttribute( - IntegerAttributeCallback callback - ) { + public void readLeaderRouterIdAttribute(IntegerAttributeCallback callback) { readLeaderRouterIdAttribute(chipClusterPtr, callback); } + public void subscribeLeaderRouterIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLeaderRouterIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDetachedRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readDetachedRoleCountAttribute(IntegerAttributeCallback callback) { readDetachedRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeDetachedRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeDetachedRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readChildRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readChildRoleCountAttribute(IntegerAttributeCallback callback) { readChildRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeChildRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeChildRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRouterRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readRouterRoleCountAttribute(IntegerAttributeCallback callback) { readRouterRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeRouterRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRouterRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLeaderRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readLeaderRoleCountAttribute(IntegerAttributeCallback callback) { readLeaderRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeLeaderRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLeaderRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttachAttemptCountAttribute( - IntegerAttributeCallback callback - ) { + public void readAttachAttemptCountAttribute(IntegerAttributeCallback callback) { readAttachAttemptCountAttribute(chipClusterPtr, callback); } + public void subscribeAttachAttemptCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartitionIdChangeCountAttribute( - IntegerAttributeCallback callback - ) { + public void readPartitionIdChangeCountAttribute(IntegerAttributeCallback callback) { readPartitionIdChangeCountAttribute(chipClusterPtr, callback); } + public void subscribePartitionIdChangeCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePartitionIdChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBetterPartitionAttachAttemptCountAttribute( - IntegerAttributeCallback callback - ) { + public void readBetterPartitionAttachAttemptCountAttribute(IntegerAttributeCallback callback) { readBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback); } + public void subscribeBetterPartitionAttachAttemptCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeBetterPartitionAttachAttemptCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readParentChangeCountAttribute( - IntegerAttributeCallback callback - ) { + public void readParentChangeCountAttribute(IntegerAttributeCallback callback) { readParentChangeCountAttribute(chipClusterPtr, callback); } + public void subscribeParentChangeCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeParentChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxTotalCountAttribute( - LongAttributeCallback callback - ) { + public void readTxTotalCountAttribute(LongAttributeCallback callback) { readTxTotalCountAttribute(chipClusterPtr, callback); } + public void subscribeTxTotalCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxUnicastCountAttribute( - LongAttributeCallback callback - ) { + public void readTxUnicastCountAttribute(LongAttributeCallback callback) { readTxUnicastCountAttribute(chipClusterPtr, callback); } + public void subscribeTxUnicastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBroadcastCountAttribute( - LongAttributeCallback callback - ) { + public void readTxBroadcastCountAttribute(LongAttributeCallback callback) { readTxBroadcastCountAttribute(chipClusterPtr, callback); } + public void subscribeTxBroadcastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxAckRequestedCountAttribute( - LongAttributeCallback callback - ) { + public void readTxAckRequestedCountAttribute(LongAttributeCallback callback) { readTxAckRequestedCountAttribute(chipClusterPtr, callback); } + public void subscribeTxAckRequestedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxAckedCountAttribute( - LongAttributeCallback callback - ) { + public void readTxAckedCountAttribute(LongAttributeCallback callback) { readTxAckedCountAttribute(chipClusterPtr, callback); } + public void subscribeTxAckedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxAckedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxNoAckRequestedCountAttribute( - LongAttributeCallback callback - ) { + public void readTxNoAckRequestedCountAttribute(LongAttributeCallback callback) { readTxNoAckRequestedCountAttribute(chipClusterPtr, callback); } + public void subscribeTxNoAckRequestedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxNoAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDataCountAttribute( - LongAttributeCallback callback - ) { + public void readTxDataCountAttribute(LongAttributeCallback callback) { readTxDataCountAttribute(chipClusterPtr, callback); } + public void subscribeTxDataCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDataPollCountAttribute( - LongAttributeCallback callback - ) { + public void readTxDataPollCountAttribute(LongAttributeCallback callback) { readTxDataPollCountAttribute(chipClusterPtr, callback); } + public void subscribeTxDataPollCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBeaconCountAttribute( - LongAttributeCallback callback - ) { + public void readTxBeaconCountAttribute(LongAttributeCallback callback) { readTxBeaconCountAttribute(chipClusterPtr, callback); } + public void subscribeTxBeaconCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBeaconRequestCountAttribute( - LongAttributeCallback callback - ) { + public void readTxBeaconRequestCountAttribute(LongAttributeCallback callback) { readTxBeaconRequestCountAttribute(chipClusterPtr, callback); } + public void subscribeTxBeaconRequestCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxOtherCountAttribute( - LongAttributeCallback callback - ) { + public void readTxOtherCountAttribute(LongAttributeCallback callback) { readTxOtherCountAttribute(chipClusterPtr, callback); } + public void subscribeTxOtherCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxRetryCountAttribute( - LongAttributeCallback callback - ) { + public void readTxRetryCountAttribute(LongAttributeCallback callback) { readTxRetryCountAttribute(chipClusterPtr, callback); } + public void subscribeTxRetryCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxRetryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback - ) { + public void readTxDirectMaxRetryExpiryCountAttribute(LongAttributeCallback callback) { readTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); } + public void subscribeTxDirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeTxDirectMaxRetryExpiryCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxIndirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback - ) { + public void readTxIndirectMaxRetryExpiryCountAttribute(LongAttributeCallback callback) { readTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); } + public void subscribeTxIndirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeTxIndirectMaxRetryExpiryCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrCcaCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrCcaCountAttribute(LongAttributeCallback callback) { readTxErrCcaCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrCcaCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrCcaCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrAbortCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrAbortCountAttribute(LongAttributeCallback callback) { readTxErrAbortCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrAbortCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrAbortCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrBusyChannelCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrBusyChannelCountAttribute(LongAttributeCallback callback) { readTxErrBusyChannelCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrBusyChannelCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrBusyChannelCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxTotalCountAttribute( - LongAttributeCallback callback - ) { + public void readRxTotalCountAttribute(LongAttributeCallback callback) { readRxTotalCountAttribute(chipClusterPtr, callback); } + public void subscribeRxTotalCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxUnicastCountAttribute( - LongAttributeCallback callback - ) { + public void readRxUnicastCountAttribute(LongAttributeCallback callback) { readRxUnicastCountAttribute(chipClusterPtr, callback); } + public void subscribeRxUnicastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBroadcastCountAttribute( - LongAttributeCallback callback - ) { + public void readRxBroadcastCountAttribute(LongAttributeCallback callback) { readRxBroadcastCountAttribute(chipClusterPtr, callback); } + public void subscribeRxBroadcastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDataCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDataCountAttribute(LongAttributeCallback callback) { readRxDataCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDataCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDataPollCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDataPollCountAttribute(LongAttributeCallback callback) { readRxDataPollCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDataPollCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBeaconCountAttribute( - LongAttributeCallback callback - ) { + public void readRxBeaconCountAttribute(LongAttributeCallback callback) { readRxBeaconCountAttribute(chipClusterPtr, callback); } + public void subscribeRxBeaconCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBeaconRequestCountAttribute( - LongAttributeCallback callback - ) { + public void readRxBeaconRequestCountAttribute(LongAttributeCallback callback) { readRxBeaconRequestCountAttribute(chipClusterPtr, callback); } + public void subscribeRxBeaconRequestCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxOtherCountAttribute( - LongAttributeCallback callback - ) { + public void readRxOtherCountAttribute(LongAttributeCallback callback) { readRxOtherCountAttribute(chipClusterPtr, callback); } + public void subscribeRxOtherCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxAddressFilteredCountAttribute( - LongAttributeCallback callback - ) { + public void readRxAddressFilteredCountAttribute(LongAttributeCallback callback) { readRxAddressFilteredCountAttribute(chipClusterPtr, callback); } + public void subscribeRxAddressFilteredCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxAddressFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDestAddrFilteredCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDestAddrFilteredCountAttribute(LongAttributeCallback callback) { readRxDestAddrFilteredCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDestAddrFilteredCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDestAddrFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDuplicatedCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDuplicatedCountAttribute(LongAttributeCallback callback) { readRxDuplicatedCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDuplicatedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDuplicatedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrNoFrameCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrNoFrameCountAttribute(LongAttributeCallback callback) { readRxErrNoFrameCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrNoFrameCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrNoFrameCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrUnknownNeighborCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrUnknownNeighborCountAttribute(LongAttributeCallback callback) { readRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrUnknownNeighborCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeRxErrUnknownNeighborCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrInvalidSrcAddrCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrInvalidSrcAddrCountAttribute(LongAttributeCallback callback) { readRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrInvalidSrcAddrCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeRxErrInvalidSrcAddrCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrSecCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrSecCountAttribute(LongAttributeCallback callback) { readRxErrSecCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrSecCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrSecCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrFcsCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrFcsCountAttribute(LongAttributeCallback callback) { readRxErrFcsCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrFcsCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrFcsCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrOtherCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrOtherCountAttribute(LongAttributeCallback callback) { readRxErrOtherCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrOtherCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveTimestampAttribute( - LongAttributeCallback callback - ) { + public void readActiveTimestampAttribute(LongAttributeCallback callback) { readActiveTimestampAttribute(chipClusterPtr, callback); } + public void subscribeActiveTimestampAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPendingTimestampAttribute( - LongAttributeCallback callback - ) { + public void readPendingTimestampAttribute(LongAttributeCallback callback) { readPendingTimestampAttribute(chipClusterPtr, callback); } + public void subscribePendingTimestampAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePendingTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDelayAttribute( - LongAttributeCallback callback - ) { + public void readDelayAttribute(LongAttributeCallback callback) { readDelayAttribute(chipClusterPtr, callback); } + public void subscribeDelayAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSecurityPolicyAttribute( - SecurityPolicyAttributeCallback callback - ) { - readSecurityPolicyAttribute(chipClusterPtr, callback); - } - public void subscribeSecurityPolicyAttribute( - SecurityPolicyAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeSecurityPolicyAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + public void readSecurityPolicyAttribute(SecurityPolicyAttributeCallback callback) { + readSecurityPolicyAttribute(chipClusterPtr, callback); + } + + public void subscribeSecurityPolicyAttribute( + SecurityPolicyAttributeCallback callback, int minInterval, int maxInterval) { + subscribeSecurityPolicyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readChannelMaskAttribute(OctetStringAttributeCallback callback) { + readChannelMaskAttribute(chipClusterPtr, callback); + } + + public void subscribeChannelMaskAttribute( + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + subscribeChannelMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOperationalDatasetComponentsAttribute( + OperationalDatasetComponentsAttributeCallback callback) { + readOperationalDatasetComponentsAttribute(chipClusterPtr, callback); + } + + public void subscribeOperationalDatasetComponentsAttribute( + OperationalDatasetComponentsAttributeCallback callback, int minInterval, int maxInterval) { + subscribeOperationalDatasetComponentsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback) { + readActiveNetworkFaultsListAttribute(chipClusterPtr, callback); + } + + public void subscribeActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeActiveNetworkFaultsListAttribute(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 readChannelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeChannelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRoutingRoleAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRoutingRoleAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNetworkNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeNetworkNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPanIdAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePanIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readExtendedPanIdAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeExtendedPanIdAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMeshLocalPrefixAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeMeshLocalPrefixAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNeighborTableListAttribute( + long chipClusterPtr, NeighborTableListAttributeCallback callback); + + private native void subscribeNeighborTableListAttribute( + long chipClusterPtr, + NeighborTableListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readRouteTableListAttribute( + long chipClusterPtr, RouteTableListAttributeCallback callback); + + private native void subscribeRouteTableListAttribute( + long chipClusterPtr, + RouteTableListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPartitionIdAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePartitionIdAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWeightingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeWeightingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStableDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStableDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLeaderRouterIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLeaderRouterIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDetachedRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeDetachedRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readChildRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeChildRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRouterRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRouterRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLeaderRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLeaderRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPartitionIdChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePartitionIdChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBetterPartitionAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBetterPartitionAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readParentChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeParentChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxAckedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxAckedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxNoAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxNoAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxRetryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxRetryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxDirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxDirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxIndirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxIndirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrCcaCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrCcaCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrAbortCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrAbortCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrBusyChannelCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrBusyChannelCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxAddressFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxAddressFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDestAddrFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDestAddrFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDuplicatedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDuplicatedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrNoFrameCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrNoFrameCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrUnknownNeighborCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrUnknownNeighborCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrInvalidSrcAddrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrInvalidSrcAddrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrSecCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrSecCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrFcsCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrFcsCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeActiveTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPendingTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePendingTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDelayAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeDelayAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSecurityPolicyAttribute( + long chipClusterPtr, SecurityPolicyAttributeCallback callback); + + private native void subscribeSecurityPolicyAttribute( + long chipClusterPtr, + SecurityPolicyAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readChannelMaskAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeChannelMaskAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOperationalDatasetComponentsAttribute( + long chipClusterPtr, OperationalDatasetComponentsAttributeCallback callback); - public void readChannelMaskAttribute( - OctetStringAttributeCallback callback - ) { - readChannelMaskAttribute(chipClusterPtr, callback); - } - public void subscribeChannelMaskAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeChannelMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeOperationalDatasetComponentsAttribute( + long chipClusterPtr, + OperationalDatasetComponentsAttributeCallback callback, + int minInterval, + int maxInterval); - public void readOperationalDatasetComponentsAttribute( - OperationalDatasetComponentsAttributeCallback callback - ) { - readOperationalDatasetComponentsAttribute(chipClusterPtr, callback); - } - public void subscribeOperationalDatasetComponentsAttribute( - OperationalDatasetComponentsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeOperationalDatasetComponentsAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readActiveNetworkFaultsListAttribute( + long chipClusterPtr, ActiveNetworkFaultsListAttributeCallback callback); - public void readActiveNetworkFaultsListAttribute( - ActiveNetworkFaultsListAttributeCallback callback - ) { - readActiveNetworkFaultsListAttribute(chipClusterPtr, callback); - } - public void subscribeActiveNetworkFaultsListAttribute( - ActiveNetworkFaultsListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeActiveNetworkFaultsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeActiveNetworkFaultsListAttribute( + long chipClusterPtr, + ActiveNetworkFaultsListAttributeCallback callback, + int minInterval, + int maxInterval); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { - readAttributeListAttribute(chipClusterPtr, callback); - } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readAttributeListAttribute( + long chipClusterPtr, AttributeListAttributeCallback callback); - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { - readFeatureMapAttribute(chipClusterPtr, callback); - } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeAttributeListAttribute( + long chipClusterPtr, + AttributeListAttributeCallback callback, + int minInterval, + int 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 readFeatureMapAttribute( + long chipClusterPtr, LongAttributeCallback callback); - private native void readChannelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeChannelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRoutingRoleAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRoutingRoleAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNetworkNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeNetworkNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPanIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePanIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readExtendedPanIdAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeExtendedPanIdAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMeshLocalPrefixAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeMeshLocalPrefixAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNeighborTableListAttribute(long chipClusterPtr, - NeighborTableListAttributeCallback callback - ); - private native void subscribeNeighborTableListAttribute(long chipClusterPtr, - NeighborTableListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readRouteTableListAttribute(long chipClusterPtr, - RouteTableListAttributeCallback callback - ); - private native void subscribeRouteTableListAttribute(long chipClusterPtr, - RouteTableListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readPartitionIdAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePartitionIdAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWeightingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeWeightingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStableDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStableDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLeaderRouterIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLeaderRouterIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDetachedRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeDetachedRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readChildRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeChildRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRouterRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRouterRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLeaderRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLeaderRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPartitionIdChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePartitionIdChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readParentChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeParentChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxAckedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxAckedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxNoAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxNoAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxRetryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxRetryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrCcaCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrCcaCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrAbortCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrAbortCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrBusyChannelCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrBusyChannelCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxAddressFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxAddressFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDestAddrFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDestAddrFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDuplicatedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDuplicatedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrNoFrameCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrNoFrameCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrUnknownNeighborCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrUnknownNeighborCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrSecCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrSecCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrFcsCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrFcsCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeActiveTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPendingTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePendingTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDelayAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeDelayAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSecurityPolicyAttribute(long chipClusterPtr, - SecurityPolicyAttributeCallback callback - ); - private native void subscribeSecurityPolicyAttribute(long chipClusterPtr, - SecurityPolicyAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readChannelMaskAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeChannelMaskAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOperationalDatasetComponentsAttribute(long chipClusterPtr, - OperationalDatasetComponentsAttributeCallback callback - ); - private native void subscribeOperationalDatasetComponentsAttribute(long chipClusterPtr, - OperationalDatasetComponentsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readActiveNetworkFaultsListAttribute(long chipClusterPtr, - ActiveNetworkFaultsListAttributeCallback callback - ); - private native void subscribeActiveNetworkFaultsListAttribute(long chipClusterPtr, - ActiveNetworkFaultsListAttributeCallback 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); + 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 TimeFormatLocalizationCluster extends BaseChipCluster { @@ -16223,105 +17276,107 @@ public TimeFormatLocalizationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SupportedCalendarTypesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface SupportedCalendarTypesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readHourFormatAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readHourFormatAttribute(IntegerAttributeCallback callback) { readHourFormatAttribute(chipClusterPtr, callback); } + public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value) { writeHourFormatAttribute(chipClusterPtr, callback, value, null); } - public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeHourFormatAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeHourFormatAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeHourFormatAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeHourFormatAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveCalendarTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readActiveCalendarTypeAttribute(IntegerAttributeCallback callback) { readActiveCalendarTypeAttribute(chipClusterPtr, callback); } + public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value) { writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, null); } - public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeActiveCalendarTypeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeActiveCalendarTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveCalendarTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readSupportedCalendarTypesAttribute( - SupportedCalendarTypesAttributeCallback callback - ) { + SupportedCalendarTypesAttributeCallback callback) { readSupportedCalendarTypesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedCalendarTypesAttribute( - SupportedCalendarTypesAttributeCallback callback - , - int minInterval, int maxInterval) { + SupportedCalendarTypesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedCalendarTypesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readHourFormatAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeHourFormatAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeHourFormatAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveCalendarTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeActiveCalendarTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeActiveCalendarTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedCalendarTypesAttribute(long chipClusterPtr, - SupportedCalendarTypesAttributeCallback callback - ); - private native void subscribeSupportedCalendarTypesAttribute(long chipClusterPtr, - SupportedCalendarTypesAttributeCallback 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); + private native void readHourFormatAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeHourFormatAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeHourFormatAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveCalendarTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeActiveCalendarTypeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeActiveCalendarTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSupportedCalendarTypesAttribute( + long chipClusterPtr, SupportedCalendarTypesAttributeCallback callback); + + private native void subscribeSupportedCalendarTypesAttribute( + long chipClusterPtr, + SupportedCalendarTypesAttributeCallback 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 UnitLocalizationCluster extends BaseChipCluster { @@ -16334,72 +17389,65 @@ public UnitLocalizationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - - public void readTemperatureUnitAttribute( - IntegerAttributeCallback callback - ) { + public void readTemperatureUnitAttribute(IntegerAttributeCallback callback) { readTemperatureUnitAttribute(chipClusterPtr, callback); } + public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value) { writeTemperatureUnitAttribute(chipClusterPtr, callback, value, null); } - public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeTemperatureUnitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeTemperatureUnitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeTemperatureUnitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeTemperatureUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTemperatureUnitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeTemperatureUnitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeTemperatureUnitAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readTemperatureUnitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeTemperatureUnitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeTemperatureUnitAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 UserLabelCluster extends BaseChipCluster { @@ -16412,58 +17460,61 @@ public UserLabelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LabelListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface LabelListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readLabelListAttribute( - LabelListAttributeCallback callback - ) { + public void readLabelListAttribute(LabelListAttributeCallback callback) { readLabelListAttribute(chipClusterPtr, callback); } - public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeLabelListAttribute( + DefaultClusterCallback callback, ArrayList value) { writeLabelListAttribute(chipClusterPtr, callback, value, null); } - public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeLabelListAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeLabelListAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLabelListAttribute( - LabelListAttributeCallback callback - , - int minInterval, int maxInterval) { + LabelListAttributeCallback callback, int minInterval, int maxInterval) { subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback callback - ); + private native void readLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback callback); + + private native void writeLabelListAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); - private native void writeLabelListAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback callback - , int minInterval, int maxInterval); + private native void subscribeLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback 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); + private native void readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class WakeOnLanCluster extends BaseChipCluster { @@ -16476,68 +17527,64 @@ public WakeOnLanCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readWakeOnLanMacAddressAttribute( - CharStringAttributeCallback callback - ) { + public void readWakeOnLanMacAddressAttribute(CharStringAttributeCallback callback) { readWakeOnLanMacAddressAttribute(chipClusterPtr, callback); } + public void subscribeWakeOnLanMacAddressAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeWakeOnLanMacAddressAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readWakeOnLanMacAddressAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeWakeOnLanMacAddressAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readWakeOnLanMacAddressAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeWakeOnLanMacAddressAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class WiFiNetworkDiagnosticsCluster extends BaseChipCluster { @@ -16550,329 +17597,272 @@ public WiFiNetworkDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetCounts(DefaultClusterCallback callback - ) { + public void resetCounts(DefaultClusterCallback callback) { resetCounts(chipClusterPtr, callback, null); } - public void resetCounts(DefaultClusterCallback callback + public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void resetCounts( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readBssidAttribute( - OctetStringAttributeCallback callback - ) { + public void readBssidAttribute(OctetStringAttributeCallback callback) { readBssidAttribute(chipClusterPtr, callback); } + public void subscribeBssidAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeBssidAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSecurityTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readSecurityTypeAttribute(IntegerAttributeCallback callback) { readSecurityTypeAttribute(chipClusterPtr, callback); } + public void subscribeSecurityTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSecurityTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWiFiVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readWiFiVersionAttribute(IntegerAttributeCallback callback) { readWiFiVersionAttribute(chipClusterPtr, callback); } + public void subscribeWiFiVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWiFiVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readChannelNumberAttribute( - IntegerAttributeCallback callback - ) { + public void readChannelNumberAttribute(IntegerAttributeCallback callback) { readChannelNumberAttribute(chipClusterPtr, callback); } + public void subscribeChannelNumberAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeChannelNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRssiAttribute( - IntegerAttributeCallback callback - ) { + public void readRssiAttribute(IntegerAttributeCallback callback) { readRssiAttribute(chipClusterPtr, callback); } + public void subscribeRssiAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRssiAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBeaconLostCountAttribute( - LongAttributeCallback callback - ) { + public void readBeaconLostCountAttribute(LongAttributeCallback callback) { readBeaconLostCountAttribute(chipClusterPtr, callback); } + public void subscribeBeaconLostCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBeaconLostCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBeaconRxCountAttribute( - LongAttributeCallback callback - ) { + public void readBeaconRxCountAttribute(LongAttributeCallback callback) { readBeaconRxCountAttribute(chipClusterPtr, callback); } + public void subscribeBeaconRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBeaconRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketMulticastRxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketMulticastRxCountAttribute(LongAttributeCallback callback) { readPacketMulticastRxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketMulticastRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketMulticastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketMulticastTxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketMulticastTxCountAttribute(LongAttributeCallback callback) { readPacketMulticastTxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketMulticastTxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketMulticastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketUnicastRxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketUnicastRxCountAttribute(LongAttributeCallback callback) { readPacketUnicastRxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketUnicastRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketUnicastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketUnicastTxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketUnicastTxCountAttribute(LongAttributeCallback callback) { readPacketUnicastTxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketUnicastTxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketUnicastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentMaxRateAttribute( - LongAttributeCallback callback - ) { + public void readCurrentMaxRateAttribute(LongAttributeCallback callback) { readCurrentMaxRateAttribute(chipClusterPtr, callback); } + public void subscribeCurrentMaxRateAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentMaxRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute( - LongAttributeCallback callback - ) { + public void readOverrunCountAttribute(LongAttributeCallback callback) { readOverrunCountAttribute(chipClusterPtr, callback); } + public void subscribeOverrunCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBssidAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeBssidAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSecurityTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSecurityTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWiFiVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeWiFiVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readChannelNumberAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeChannelNumberAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRssiAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRssiAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBeaconLostCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBeaconLostCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBeaconRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBeaconRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketMulticastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketMulticastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketMulticastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketMulticastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketUnicastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketUnicastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketUnicastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketUnicastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentMaxRateAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentMaxRateAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readBssidAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeBssidAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSecurityTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSecurityTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWiFiVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeWiFiVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readChannelNumberAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeChannelNumberAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRssiAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRssiAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBeaconLostCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBeaconLostCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBeaconRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBeaconRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketMulticastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketMulticastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketMulticastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketMulticastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketUnicastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketUnicastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketUnicastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketUnicastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentMaxRateAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentMaxRateAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback 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 WindowCoveringCluster extends BaseChipCluster { @@ -16885,556 +17875,581 @@ public WindowCoveringCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void downOrClose(DefaultClusterCallback callback - ) { + public void downOrClose(DefaultClusterCallback callback) { downOrClose(chipClusterPtr, callback, null); } - public void downOrClose(DefaultClusterCallback callback + public void downOrClose(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { downOrClose(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void goToLiftPercentage(DefaultClusterCallback callback - , Integer liftPercentageValue, Integer liftPercent100thsValue) { - goToLiftPercentage(chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, null); + public void goToLiftPercentage( + DefaultClusterCallback callback, + Integer liftPercentageValue, + Integer liftPercent100thsValue) { + goToLiftPercentage( + chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, null); } - public void goToLiftPercentage(DefaultClusterCallback callback - , Integer liftPercentageValue, Integer liftPercent100thsValue - , int timedInvokeTimeoutMs) { - goToLiftPercentage(chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, timedInvokeTimeoutMs); + public void goToLiftPercentage( + DefaultClusterCallback callback, + Integer liftPercentageValue, + Integer liftPercent100thsValue, + int timedInvokeTimeoutMs) { + goToLiftPercentage( + chipClusterPtr, + callback, + liftPercentageValue, + liftPercent100thsValue, + timedInvokeTimeoutMs); } - public void goToLiftValue(DefaultClusterCallback callback - , Integer liftValue) { + public void goToLiftValue(DefaultClusterCallback callback, Integer liftValue) { goToLiftValue(chipClusterPtr, callback, liftValue, null); } - public void goToLiftValue(DefaultClusterCallback callback - , Integer liftValue - , int timedInvokeTimeoutMs) { + public void goToLiftValue( + DefaultClusterCallback callback, Integer liftValue, int timedInvokeTimeoutMs) { goToLiftValue(chipClusterPtr, callback, liftValue, timedInvokeTimeoutMs); } - public void goToTiltPercentage(DefaultClusterCallback callback - , Integer tiltPercentageValue, Integer tiltPercent100thsValue) { - goToTiltPercentage(chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, null); + public void goToTiltPercentage( + DefaultClusterCallback callback, + Integer tiltPercentageValue, + Integer tiltPercent100thsValue) { + goToTiltPercentage( + chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, null); } - public void goToTiltPercentage(DefaultClusterCallback callback - , Integer tiltPercentageValue, Integer tiltPercent100thsValue - , int timedInvokeTimeoutMs) { - goToTiltPercentage(chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, timedInvokeTimeoutMs); + public void goToTiltPercentage( + DefaultClusterCallback callback, + Integer tiltPercentageValue, + Integer tiltPercent100thsValue, + int timedInvokeTimeoutMs) { + goToTiltPercentage( + chipClusterPtr, + callback, + tiltPercentageValue, + tiltPercent100thsValue, + timedInvokeTimeoutMs); } - public void goToTiltValue(DefaultClusterCallback callback - , Integer tiltValue) { + public void goToTiltValue(DefaultClusterCallback callback, Integer tiltValue) { goToTiltValue(chipClusterPtr, callback, tiltValue, null); } - public void goToTiltValue(DefaultClusterCallback callback - , Integer tiltValue - , int timedInvokeTimeoutMs) { + public void goToTiltValue( + DefaultClusterCallback callback, Integer tiltValue, int timedInvokeTimeoutMs) { goToTiltValue(chipClusterPtr, callback, tiltValue, timedInvokeTimeoutMs); } - public void stopMotion(DefaultClusterCallback callback - ) { + public void stopMotion(DefaultClusterCallback callback) { stopMotion(chipClusterPtr, callback, null); } - public void stopMotion(DefaultClusterCallback callback + public void stopMotion(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { stopMotion(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void upOrOpen(DefaultClusterCallback callback - ) { + public void upOrOpen(DefaultClusterCallback callback) { upOrOpen(chipClusterPtr, callback, null); } - public void upOrOpen(DefaultClusterCallback callback + public void upOrOpen(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { upOrOpen(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void downOrClose(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToLiftPercentage(long chipClusterPtr, DefaultClusterCallback Callback - , Integer liftPercentageValue, Integer liftPercent100thsValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToLiftValue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer liftValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToTiltPercentage(long chipClusterPtr, DefaultClusterCallback Callback - , Integer tiltPercentageValue, Integer tiltPercent100thsValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToTiltValue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer tiltValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopMotion(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void upOrOpen(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - - public interface CurrentPositionLiftAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionTiltAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionLiftPercentageAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionTiltPercentageAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface TargetPositionLiftPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface TargetPositionTiltPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionLiftPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionTiltPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readTypeAttribute( - IntegerAttributeCallback callback - ) { + private native void downOrClose( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToLiftPercentage( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer liftPercentageValue, + Integer liftPercent100thsValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToLiftValue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer liftValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToTiltPercentage( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer tiltPercentageValue, + Integer tiltPercent100thsValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToTiltValue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer tiltValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopMotion( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void upOrOpen( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface CurrentPositionLiftAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionTiltAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionLiftPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionTiltPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface TargetPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface TargetPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readTypeAttribute(IntegerAttributeCallback callback) { readTypeAttribute(chipClusterPtr, callback); } + public void subscribeTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionLiftAttribute( - CurrentPositionLiftAttributeCallback callback - ) { + public void readCurrentPositionLiftAttribute(CurrentPositionLiftAttributeCallback callback) { readCurrentPositionLiftAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionLiftAttribute( - CurrentPositionLiftAttributeCallback callback - , - int minInterval, int maxInterval) { + CurrentPositionLiftAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentPositionLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionTiltAttribute( - CurrentPositionTiltAttributeCallback callback - ) { + public void readCurrentPositionTiltAttribute(CurrentPositionTiltAttributeCallback callback) { readCurrentPositionTiltAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionTiltAttribute( - CurrentPositionTiltAttributeCallback callback - , - int minInterval, int maxInterval) { + CurrentPositionTiltAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentPositionTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readConfigStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readConfigStatusAttribute(IntegerAttributeCallback callback) { readConfigStatusAttribute(chipClusterPtr, callback); } + public void subscribeConfigStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeConfigStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionLiftPercentageAttribute( - CurrentPositionLiftPercentageAttributeCallback callback - ) { + CurrentPositionLiftPercentageAttributeCallback callback) { readCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionLiftPercentageAttribute( - CurrentPositionLiftPercentageAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionLiftPercentageAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCurrentPositionLiftPercentageAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionTiltPercentageAttribute( - CurrentPositionTiltPercentageAttributeCallback callback - ) { + CurrentPositionTiltPercentageAttributeCallback callback) { readCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionTiltPercentageAttribute( - CurrentPositionTiltPercentageAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionTiltPercentageAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCurrentPositionTiltPercentageAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperationalStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readOperationalStatusAttribute(IntegerAttributeCallback callback) { readOperationalStatusAttribute(chipClusterPtr, callback); } + public void subscribeOperationalStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOperationalStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTargetPositionLiftPercent100thsAttribute( - TargetPositionLiftPercent100thsAttributeCallback callback - ) { + TargetPositionLiftPercent100thsAttributeCallback callback) { readTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeTargetPositionLiftPercent100thsAttribute( - TargetPositionLiftPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + TargetPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeTargetPositionLiftPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readTargetPositionTiltPercent100thsAttribute( - TargetPositionTiltPercent100thsAttributeCallback callback - ) { + TargetPositionTiltPercent100thsAttributeCallback callback) { readTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeTargetPositionTiltPercent100thsAttribute( - TargetPositionTiltPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + TargetPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeTargetPositionTiltPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readEndProductTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readEndProductTypeAttribute(IntegerAttributeCallback callback) { readEndProductTypeAttribute(chipClusterPtr, callback); } + public void subscribeEndProductTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEndProductTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionLiftPercent100thsAttribute( - CurrentPositionLiftPercent100thsAttributeCallback callback - ) { + CurrentPositionLiftPercent100thsAttributeCallback callback) { readCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionLiftPercent100thsAttribute( - CurrentPositionLiftPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeCurrentPositionLiftPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionTiltPercent100thsAttribute( - CurrentPositionTiltPercent100thsAttributeCallback callback - ) { + CurrentPositionTiltPercent100thsAttributeCallback callback) { readCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionTiltPercent100thsAttribute( - CurrentPositionTiltPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeCurrentPositionTiltPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledOpenLimitLiftAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledOpenLimitLiftAttribute(IntegerAttributeCallback callback) { readInstalledOpenLimitLiftAttribute(chipClusterPtr, callback); } + public void subscribeInstalledOpenLimitLiftAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInstalledOpenLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledClosedLimitLiftAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledClosedLimitLiftAttribute(IntegerAttributeCallback callback) { readInstalledClosedLimitLiftAttribute(chipClusterPtr, callback); } + public void subscribeInstalledClosedLimitLiftAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeInstalledClosedLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeInstalledClosedLimitLiftAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledOpenLimitTiltAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledOpenLimitTiltAttribute(IntegerAttributeCallback callback) { readInstalledOpenLimitTiltAttribute(chipClusterPtr, callback); } + public void subscribeInstalledOpenLimitTiltAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInstalledOpenLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledClosedLimitTiltAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledClosedLimitTiltAttribute(IntegerAttributeCallback callback) { readInstalledClosedLimitTiltAttribute(chipClusterPtr, callback); } + public void subscribeInstalledClosedLimitTiltAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeInstalledClosedLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeInstalledClosedLimitTiltAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readModeAttribute( - IntegerAttributeCallback callback - ) { + public void readModeAttribute(IntegerAttributeCallback callback) { readModeAttribute(chipClusterPtr, callback); } + public void writeModeAttribute(DefaultClusterCallback callback, Integer value) { writeModeAttribute(chipClusterPtr, callback, value, null); } - public void writeModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSafetyStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readSafetyStatusAttribute(IntegerAttributeCallback callback) { readSafetyStatusAttribute(chipClusterPtr, callback); } + public void subscribeSafetyStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftAttribute(long chipClusterPtr, - CurrentPositionLiftAttributeCallback callback - ); - private native void subscribeCurrentPositionLiftAttribute(long chipClusterPtr, - CurrentPositionLiftAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentPositionTiltAttribute(long chipClusterPtr, - CurrentPositionTiltAttributeCallback callback - ); - private native void subscribeCurrentPositionTiltAttribute(long chipClusterPtr, - CurrentPositionTiltAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readConfigStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeConfigStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftPercentageAttribute(long chipClusterPtr, - CurrentPositionLiftPercentageAttributeCallback callback - ); - private native void subscribeCurrentPositionLiftPercentageAttribute(long chipClusterPtr, - CurrentPositionLiftPercentageAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentPositionTiltPercentageAttribute(long chipClusterPtr, - CurrentPositionTiltPercentageAttributeCallback callback - ); - private native void subscribeCurrentPositionTiltPercentageAttribute(long chipClusterPtr, - CurrentPositionTiltPercentageAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOperationalStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOperationalStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, - TargetPositionLiftPercent100thsAttributeCallback callback - ); - private native void subscribeTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, - TargetPositionLiftPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, - TargetPositionTiltPercent100thsAttributeCallback callback - ); - private native void subscribeTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, - TargetPositionTiltPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readEndProductTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEndProductTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, - CurrentPositionLiftPercent100thsAttributeCallback callback - ); - private native void subscribeCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, - CurrentPositionLiftPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, - CurrentPositionTiltPercent100thsAttributeCallback callback - ); - private native void subscribeCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, - CurrentPositionTiltPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readInstalledOpenLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledOpenLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInstalledClosedLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledClosedLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInstalledOpenLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledOpenLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInstalledClosedLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledClosedLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftAttribute( + long chipClusterPtr, CurrentPositionLiftAttributeCallback callback); + + private native void subscribeCurrentPositionLiftAttribute( + long chipClusterPtr, + CurrentPositionLiftAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentPositionTiltAttribute( + long chipClusterPtr, CurrentPositionTiltAttributeCallback callback); + + private native void subscribeCurrentPositionTiltAttribute( + long chipClusterPtr, + CurrentPositionTiltAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readConfigStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeConfigStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercentageAttribute( + long chipClusterPtr, CurrentPositionLiftPercentageAttributeCallback callback); + + private native void subscribeCurrentPositionLiftPercentageAttribute( + long chipClusterPtr, + CurrentPositionLiftPercentageAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentPositionTiltPercentageAttribute( + long chipClusterPtr, CurrentPositionTiltPercentageAttributeCallback callback); + + private native void subscribeCurrentPositionTiltPercentageAttribute( + long chipClusterPtr, + CurrentPositionTiltPercentageAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOperationalStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOperationalStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTargetPositionLiftPercent100thsAttribute( + long chipClusterPtr, TargetPositionLiftPercent100thsAttributeCallback callback); + + private native void subscribeTargetPositionLiftPercent100thsAttribute( + long chipClusterPtr, + TargetPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readTargetPositionTiltPercent100thsAttribute( + long chipClusterPtr, TargetPositionTiltPercent100thsAttributeCallback callback); + + private native void subscribeTargetPositionTiltPercent100thsAttribute( + long chipClusterPtr, + TargetPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEndProductTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEndProductTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercent100thsAttribute( + long chipClusterPtr, CurrentPositionLiftPercent100thsAttributeCallback callback); + + private native void subscribeCurrentPositionLiftPercent100thsAttribute( + long chipClusterPtr, + CurrentPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentPositionTiltPercent100thsAttribute( + long chipClusterPtr, CurrentPositionTiltPercent100thsAttributeCallback callback); + + private native void subscribeCurrentPositionTiltPercent100thsAttribute( + long chipClusterPtr, + CurrentPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readInstalledOpenLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledOpenLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledClosedLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInstalledOpenLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledOpenLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledClosedLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback 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); } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java index 19853055a448c2..bbbf6488468e15 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java @@ -24,2110 +24,1975 @@ import java.util.Optional; public class ChipStructs { -public static class AccessControlClusterTarget { -public @Nullable Long cluster; -public @Nullable Integer endpoint; -public @Nullable Long deviceType; - - public AccessControlClusterTarget( - @Nullable Long cluster - , @Nullable Integer endpoint - , @Nullable Long deviceType - ) { - this.cluster = cluster; - this.endpoint = endpoint; - this.deviceType = deviceType; + public static class AccessControlClusterTarget { + public @Nullable Long cluster; + public @Nullable Integer endpoint; + public @Nullable Long deviceType; + + public AccessControlClusterTarget( + @Nullable Long cluster, @Nullable Integer endpoint, @Nullable Long deviceType) { + this.cluster = cluster; + this.endpoint = endpoint; + this.deviceType = deviceType; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterTarget {\n"); + output.append("\tcluster: "); + output.append(cluster); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("\tdeviceType: "); + output.append(deviceType); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class AccessControlClusterAccessControlEntry { + public Integer fabricIndex; + public Integer privilege; + public Integer authMode; + public @Nullable ArrayList subjects; + public @Nullable ArrayList targets; + + public AccessControlClusterAccessControlEntry( + Integer fabricIndex, + Integer privilege, + Integer authMode, + @Nullable ArrayList subjects, + @Nullable ArrayList targets) { + this.fabricIndex = fabricIndex; + this.privilege = privilege; + this.authMode = authMode; + this.subjects = subjects; + this.targets = targets; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterAccessControlEntry {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tprivilege: "); + output.append(privilege); + output.append("\n"); + output.append("\tauthMode: "); + output.append(authMode); + output.append("\n"); + output.append("\tsubjects: "); + output.append(subjects); + output.append("\n"); + output.append("\ttargets: "); + output.append(targets); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class AccessControlClusterExtensionEntry { + public Integer fabricIndex; + public byte[] data; + + public AccessControlClusterExtensionEntry(Integer fabricIndex, byte[] data) { + this.fabricIndex = fabricIndex; + this.data = data; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterExtensionEntry {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tdata: "); + output.append(Arrays.toString(data)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ApplicationBasicClusterApplicationBasicApplication { + public Integer catalogVendorId; + public String applicationId; + + public ApplicationBasicClusterApplicationBasicApplication( + Integer catalogVendorId, String applicationId) { + this.catalogVendorId = catalogVendorId; + this.applicationId = applicationId; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationBasicClusterApplicationBasicApplication {\n"); + output.append("\tcatalogVendorId: "); + output.append(catalogVendorId); + output.append("\n"); + output.append("\tapplicationId: "); + output.append(applicationId); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ApplicationLauncherClusterApplicationLauncherApplication { + public Integer catalogVendorId; + public String applicationId; + + public ApplicationLauncherClusterApplicationLauncherApplication( + Integer catalogVendorId, String applicationId) { + this.catalogVendorId = catalogVendorId; + this.applicationId = applicationId; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationLauncherClusterApplicationLauncherApplication {\n"); + output.append("\tcatalogVendorId: "); + output.append(catalogVendorId); + output.append("\n"); + output.append("\tapplicationId: "); + output.append(applicationId); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ApplicationLauncherClusterApplicationEP { + public ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application; + public String endpoint; + + public ApplicationLauncherClusterApplicationEP( + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + String endpoint) { + this.application = application; + this.endpoint = endpoint; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationLauncherClusterApplicationEP {\n"); + output.append("\tapplication: "); + output.append(application); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class AudioOutputClusterOutputInfo { + public Integer index; + public Integer outputType; + public String name; + + public AudioOutputClusterOutputInfo(Integer index, Integer outputType, String name) { + this.index = index; + this.outputType = outputType; + this.name = name; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AudioOutputClusterOutputInfo {\n"); + output.append("\tindex: "); + output.append(index); + output.append("\n"); + output.append("\toutputType: "); + output.append(outputType); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class BridgedActionsClusterActionStruct { + public Integer actionID; + public String name; + public Integer type; + public Integer endpointListID; + public Integer supportedCommands; + public Integer status; + + public BridgedActionsClusterActionStruct( + Integer actionID, + String name, + Integer type, + Integer endpointListID, + Integer supportedCommands, + Integer status) { + this.actionID = actionID; + this.name = name; + this.type = type; + this.endpointListID = endpointListID; + this.supportedCommands = supportedCommands; + this.status = status; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedActionsClusterActionStruct {\n"); + output.append("\tactionID: "); + output.append(actionID); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tendpointListID: "); + output.append(endpointListID); + output.append("\n"); + output.append("\tsupportedCommands: "); + output.append(supportedCommands); + output.append("\n"); + output.append("\tstatus: "); + output.append(status); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class BridgedActionsClusterEndpointListStruct { + public Integer endpointListID; + public String name; + public Integer type; + public ArrayList endpoints; + + public BridgedActionsClusterEndpointListStruct( + Integer endpointListID, String name, Integer type, ArrayList endpoints) { + this.endpointListID = endpointListID; + this.name = name; + this.type = type; + this.endpoints = endpoints; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedActionsClusterEndpointListStruct {\n"); + output.append("\tendpointListID: "); + output.append(endpointListID); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tendpoints: "); + output.append(endpoints); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ChannelClusterChannelInfo { + public Integer majorNumber; + public Integer minorNumber; + public String name; + public String callSign; + public String affiliateCallSign; + + public ChannelClusterChannelInfo( + Integer majorNumber, + Integer minorNumber, + String name, + String callSign, + String affiliateCallSign) { + this.majorNumber = majorNumber; + this.minorNumber = minorNumber; + this.name = name; + this.callSign = callSign; + this.affiliateCallSign = affiliateCallSign; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ChannelClusterChannelInfo {\n"); + output.append("\tmajorNumber: "); + output.append(majorNumber); + output.append("\n"); + output.append("\tminorNumber: "); + output.append(minorNumber); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tcallSign: "); + output.append(callSign); + output.append("\n"); + output.append("\taffiliateCallSign: "); + output.append(affiliateCallSign); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ChannelClusterLineupInfo { + public String operatorName; + public String lineupName; + public String postalCode; + public Integer lineupInfoType; + + public ChannelClusterLineupInfo( + String operatorName, String lineupName, String postalCode, Integer lineupInfoType) { + this.operatorName = operatorName; + this.lineupName = lineupName; + this.postalCode = postalCode; + this.lineupInfoType = lineupInfoType; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ChannelClusterLineupInfo {\n"); + output.append("\toperatorName: "); + output.append(operatorName); + output.append("\n"); + output.append("\tlineupName: "); + output.append(lineupName); + output.append("\n"); + output.append("\tpostalCode: "); + output.append(postalCode); + output.append("\n"); + output.append("\tlineupInfoType: "); + output.append(lineupInfoType); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterDimension { + public Double width; + public Double height; + public Integer metric; + + public ContentLauncherClusterDimension(Double width, Double height, Integer metric) { + this.width = width; + this.height = height; + this.metric = metric; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterDimension {\n"); + output.append("\twidth: "); + output.append(width); + output.append("\n"); + output.append("\theight: "); + output.append(height); + output.append("\n"); + output.append("\tmetric: "); + output.append(metric); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterAdditionalInfo { + public String name; + public String value; + + public ContentLauncherClusterAdditionalInfo(String name, String value) { + this.name = name; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterAdditionalInfo {\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterParameter { + public Integer type; + public String value; + public ArrayList externalIDList; + + public ContentLauncherClusterParameter( + Integer type, + String value, + ArrayList externalIDList) { + this.type = type; + this.value = value; + this.externalIDList = externalIDList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterParameter {\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("\texternalIDList: "); + output.append(externalIDList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterContentSearch { + public ArrayList parameterList; + + public ContentLauncherClusterContentSearch( + ArrayList parameterList) { + this.parameterList = parameterList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterContentSearch {\n"); + output.append("\tparameterList: "); + output.append(parameterList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterStyleInformation { + public String imageUrl; + public String color; + public ChipStructs.ContentLauncherClusterDimension size; + + public ContentLauncherClusterStyleInformation( + String imageUrl, String color, ChipStructs.ContentLauncherClusterDimension size) { + this.imageUrl = imageUrl; + this.color = color; + this.size = size; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterStyleInformation {\n"); + output.append("\timageUrl: "); + output.append(imageUrl); + output.append("\n"); + output.append("\tcolor: "); + output.append(color); + output.append("\n"); + output.append("\tsize: "); + output.append(size); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterBrandingInformation { + public String providerName; + public ChipStructs.ContentLauncherClusterStyleInformation background; + public ChipStructs.ContentLauncherClusterStyleInformation logo; + public ChipStructs.ContentLauncherClusterStyleInformation progressBar; + public ChipStructs.ContentLauncherClusterStyleInformation splash; + public ChipStructs.ContentLauncherClusterStyleInformation waterMark; + + public ContentLauncherClusterBrandingInformation( + String providerName, + ChipStructs.ContentLauncherClusterStyleInformation background, + ChipStructs.ContentLauncherClusterStyleInformation logo, + ChipStructs.ContentLauncherClusterStyleInformation progressBar, + ChipStructs.ContentLauncherClusterStyleInformation splash, + ChipStructs.ContentLauncherClusterStyleInformation waterMark) { + this.providerName = providerName; + this.background = background; + this.logo = logo; + this.progressBar = progressBar; + this.splash = splash; + this.waterMark = waterMark; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterBrandingInformation {\n"); + output.append("\tproviderName: "); + output.append(providerName); + output.append("\n"); + output.append("\tbackground: "); + output.append(background); + output.append("\n"); + output.append("\tlogo: "); + output.append(logo); + output.append("\n"); + output.append("\tprogressBar: "); + output.append(progressBar); + output.append("\n"); + output.append("\tsplash: "); + output.append(splash); + output.append("\n"); + output.append("\twaterMark: "); + output.append(waterMark); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class DescriptorClusterDeviceType { + public Long type; + public Integer revision; + + public DescriptorClusterDeviceType(Long type, Integer revision) { + this.type = type; + this.revision = revision; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DescriptorClusterDeviceType {\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\trevision: "); + output.append(revision); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class DoorLockClusterDlCredential { + public Integer credentialType; + public Integer credentialIndex; + + public DoorLockClusterDlCredential(Integer credentialType, Integer credentialIndex) { + this.credentialType = credentialType; + this.credentialIndex = credentialIndex; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DoorLockClusterDlCredential {\n"); + output.append("\tcredentialType: "); + output.append(credentialType); + output.append("\n"); + output.append("\tcredentialIndex: "); + output.append(credentialIndex); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class FixedLabelClusterLabelStruct { + public String label; + public String value; + + public FixedLabelClusterLabelStruct(String label, String value) { + this.label = label; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("FixedLabelClusterLabelStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GeneralCommissioningClusterBasicCommissioningInfoType { + public Long failSafeExpiryLengthMs; + + public GeneralCommissioningClusterBasicCommissioningInfoType(Long failSafeExpiryLengthMs) { + this.failSafeExpiryLengthMs = failSafeExpiryLengthMs; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GeneralCommissioningClusterBasicCommissioningInfoType {\n"); + output.append("\tfailSafeExpiryLengthMs: "); + output.append(failSafeExpiryLengthMs); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GeneralDiagnosticsClusterNetworkInterfaceType { + public String name; + public Boolean fabricConnected; + public Boolean offPremiseServicesReachableIPv4; + public Boolean offPremiseServicesReachableIPv6; + public byte[] hardwareAddress; + public Integer type; + + public GeneralDiagnosticsClusterNetworkInterfaceType( + String name, + Boolean fabricConnected, + Boolean offPremiseServicesReachableIPv4, + Boolean offPremiseServicesReachableIPv6, + byte[] hardwareAddress, + Integer type) { + this.name = name; + this.fabricConnected = fabricConnected; + this.offPremiseServicesReachableIPv4 = offPremiseServicesReachableIPv4; + this.offPremiseServicesReachableIPv6 = offPremiseServicesReachableIPv6; + this.hardwareAddress = hardwareAddress; + this.type = type; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GeneralDiagnosticsClusterNetworkInterfaceType {\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tfabricConnected: "); + output.append(fabricConnected); + output.append("\n"); + output.append("\toffPremiseServicesReachableIPv4: "); + output.append(offPremiseServicesReachableIPv4); + output.append("\n"); + output.append("\toffPremiseServicesReachableIPv6: "); + output.append(offPremiseServicesReachableIPv6); + output.append("\n"); + output.append("\thardwareAddress: "); + output.append(Arrays.toString(hardwareAddress)); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GroupKeyManagementClusterGroupInfo { + public Integer fabricIndex; + public Integer groupId; + public ArrayList endpoints; + public String groupName; + + public GroupKeyManagementClusterGroupInfo( + Integer fabricIndex, Integer groupId, ArrayList endpoints, String groupName) { + this.fabricIndex = fabricIndex; + this.groupId = groupId; + this.endpoints = endpoints; + this.groupName = groupName; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupInfo {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tgroupId: "); + output.append(groupId); + output.append("\n"); + output.append("\tendpoints: "); + output.append(endpoints); + output.append("\n"); + output.append("\tgroupName: "); + output.append(groupName); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GroupKeyManagementClusterGroupKey { + public Integer fabricIndex; + public Integer groupId; + public Integer groupKeySetID; + + public GroupKeyManagementClusterGroupKey( + Integer fabricIndex, Integer groupId, Integer groupKeySetID) { + this.fabricIndex = fabricIndex; + this.groupId = groupId; + this.groupKeySetID = groupKeySetID; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupKey {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tgroupId: "); + output.append(groupId); + output.append("\n"); + output.append("\tgroupKeySetID: "); + output.append(groupKeySetID); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GroupKeyManagementClusterGroupKeySet { + public Integer groupKeySetID; + public Integer securityPolicy; + public byte[] epochKey0; + public Long epochStartTime0; + public byte[] epochKey1; + public Long epochStartTime1; + public byte[] epochKey2; + public Long epochStartTime2; + + public GroupKeyManagementClusterGroupKeySet( + Integer groupKeySetID, + Integer securityPolicy, + byte[] epochKey0, + Long epochStartTime0, + byte[] epochKey1, + Long epochStartTime1, + byte[] epochKey2, + Long epochStartTime2) { + this.groupKeySetID = groupKeySetID; + this.securityPolicy = securityPolicy; + this.epochKey0 = epochKey0; + this.epochStartTime0 = epochStartTime0; + this.epochKey1 = epochKey1; + this.epochStartTime1 = epochStartTime1; + this.epochKey2 = epochKey2; + this.epochStartTime2 = epochStartTime2; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupKeySet {\n"); + output.append("\tgroupKeySetID: "); + output.append(groupKeySetID); + output.append("\n"); + output.append("\tsecurityPolicy: "); + output.append(securityPolicy); + output.append("\n"); + output.append("\tepochKey0: "); + output.append(Arrays.toString(epochKey0)); + output.append("\n"); + output.append("\tepochStartTime0: "); + output.append(epochStartTime0); + output.append("\n"); + output.append("\tepochKey1: "); + output.append(Arrays.toString(epochKey1)); + output.append("\n"); + output.append("\tepochStartTime1: "); + output.append(epochStartTime1); + output.append("\n"); + output.append("\tepochKey2: "); + output.append(Arrays.toString(epochKey2)); + output.append("\n"); + output.append("\tepochStartTime2: "); + output.append(epochStartTime2); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class MediaInputClusterInputInfo { + public Integer index; + public Integer inputType; + public String name; + public String description; + + public MediaInputClusterInputInfo( + Integer index, Integer inputType, String name, String description) { + this.index = index; + this.inputType = inputType; + this.name = name; + this.description = description; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("MediaInputClusterInputInfo {\n"); + output.append("\tindex: "); + output.append(index); + output.append("\n"); + output.append("\tinputType: "); + output.append(inputType); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tdescription: "); + output.append(description); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class MediaPlaybackClusterPlaybackPosition { + public Long updatedAt; + public Long position; + + public MediaPlaybackClusterPlaybackPosition(Long updatedAt, Long position) { + this.updatedAt = updatedAt; + this.position = position; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("MediaPlaybackClusterPlaybackPosition {\n"); + output.append("\tupdatedAt: "); + output.append(updatedAt); + output.append("\n"); + output.append("\tposition: "); + output.append(position); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ModeSelectClusterModeOptionStruct { + public String label; + public Integer mode; + public Long semanticTag; + + public ModeSelectClusterModeOptionStruct(String label, Integer mode, Long semanticTag) { + this.label = label; + this.mode = mode; + this.semanticTag = semanticTag; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ModeSelectClusterModeOptionStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tmode: "); + output.append(mode); + output.append("\n"); + output.append("\tsemanticTag: "); + output.append(semanticTag); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ModeSelectClusterSemanticTag { + public Integer mfgCode; + public Integer value; + + public ModeSelectClusterSemanticTag(Integer mfgCode, Integer value) { + this.mfgCode = mfgCode; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ModeSelectClusterSemanticTag {\n"); + output.append("\tmfgCode: "); + output.append(mfgCode); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class NetworkCommissioningClusterNetworkInfo { + public byte[] networkID; + public Boolean connected; + + public NetworkCommissioningClusterNetworkInfo(byte[] networkID, Boolean connected) { + this.networkID = networkID; + this.connected = connected; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterNetworkInfo {\n"); + output.append("\tnetworkID: "); + output.append(Arrays.toString(networkID)); + output.append("\n"); + output.append("\tconnected: "); + output.append(connected); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class NetworkCommissioningClusterThreadInterfaceScanResult { + public Long panId; + public Long extendedPanId; + public String networkName; + public Integer channel; + public Integer version; + public Long extendedAddress; + public Integer rssi; + public Integer lqi; + + public NetworkCommissioningClusterThreadInterfaceScanResult( + Long panId, + Long extendedPanId, + String networkName, + Integer channel, + Integer version, + Long extendedAddress, + Integer rssi, + Integer lqi) { + this.panId = panId; + this.extendedPanId = extendedPanId; + this.networkName = networkName; + this.channel = channel; + this.version = version; + this.extendedAddress = extendedAddress; + this.rssi = rssi; + this.lqi = lqi; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterThreadInterfaceScanResult {\n"); + output.append("\tpanId: "); + output.append(panId); + output.append("\n"); + output.append("\textendedPanId: "); + output.append(extendedPanId); + output.append("\n"); + output.append("\tnetworkName: "); + output.append(networkName); + output.append("\n"); + output.append("\tchannel: "); + output.append(channel); + output.append("\n"); + output.append("\tversion: "); + output.append(version); + output.append("\n"); + output.append("\textendedAddress: "); + output.append(extendedAddress); + output.append("\n"); + output.append("\trssi: "); + output.append(rssi); + output.append("\n"); + output.append("\tlqi: "); + output.append(lqi); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class NetworkCommissioningClusterWiFiInterfaceScanResult { + public Integer security; + public byte[] ssid; + public byte[] bssid; + public Integer channel; + public Integer wiFiBand; + public Integer rssi; + + public NetworkCommissioningClusterWiFiInterfaceScanResult( + Integer security, + byte[] ssid, + byte[] bssid, + Integer channel, + Integer wiFiBand, + Integer rssi) { + this.security = security; + this.ssid = ssid; + this.bssid = bssid; + this.channel = channel; + this.wiFiBand = wiFiBand; + this.rssi = rssi; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterWiFiInterfaceScanResult {\n"); + output.append("\tsecurity: "); + output.append(security); + output.append("\n"); + output.append("\tssid: "); + output.append(Arrays.toString(ssid)); + output.append("\n"); + output.append("\tbssid: "); + output.append(Arrays.toString(bssid)); + output.append("\n"); + output.append("\tchannel: "); + output.append(channel); + output.append("\n"); + output.append("\twiFiBand: "); + output.append(wiFiBand); + output.append("\n"); + output.append("\trssi: "); + output.append(rssi); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class OtaSoftwareUpdateRequestorClusterProviderLocation { + public Integer fabricIndex; + public Long providerNodeID; + public Integer endpoint; + + public OtaSoftwareUpdateRequestorClusterProviderLocation( + Integer fabricIndex, Long providerNodeID, Integer endpoint) { + this.fabricIndex = fabricIndex; + this.providerNodeID = providerNodeID; + this.endpoint = endpoint; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OtaSoftwareUpdateRequestorClusterProviderLocation {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tproviderNodeID: "); + output.append(providerNodeID); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class OperationalCredentialsClusterFabricDescriptor { + public Integer fabricIndex; + public byte[] rootPublicKey; + public Integer vendorId; + public Long fabricId; + public Long nodeId; + public String label; + + public OperationalCredentialsClusterFabricDescriptor( + Integer fabricIndex, + byte[] rootPublicKey, + Integer vendorId, + Long fabricId, + Long nodeId, + String label) { + this.fabricIndex = fabricIndex; + this.rootPublicKey = rootPublicKey; + this.vendorId = vendorId; + this.fabricId = fabricId; + this.nodeId = nodeId; + this.label = label; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OperationalCredentialsClusterFabricDescriptor {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\trootPublicKey: "); + output.append(Arrays.toString(rootPublicKey)); + output.append("\n"); + output.append("\tvendorId: "); + output.append(vendorId); + output.append("\n"); + output.append("\tfabricId: "); + output.append(fabricId); + output.append("\n"); + output.append("\tnodeId: "); + output.append(nodeId); + output.append("\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class OperationalCredentialsClusterNOCStruct { + public Integer fabricIndex; + public byte[] noc; + public @Nullable byte[] icac; + + public OperationalCredentialsClusterNOCStruct( + Integer fabricIndex, byte[] noc, @Nullable byte[] icac) { + this.fabricIndex = fabricIndex; + this.noc = noc; + this.icac = icac; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OperationalCredentialsClusterNOCStruct {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tnoc: "); + output.append(Arrays.toString(noc)); + output.append("\n"); + output.append("\ticac: "); + output.append(Arrays.toString(icac)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class PowerSourceClusterBatChargeFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterBatChargeFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatChargeFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class PowerSourceClusterBatFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterBatFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class PowerSourceClusterWiredFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterWiredFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterWiredFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ScenesClusterSceneExtensionFieldSet { + public Long clusterId; + public Integer length; + public Integer value; + + public ScenesClusterSceneExtensionFieldSet(Long clusterId, Integer length, Integer value) { + this.clusterId = clusterId; + this.length = length; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ScenesClusterSceneExtensionFieldSet {\n"); + output.append("\tclusterId: "); + output.append(clusterId); + output.append("\n"); + output.append("\tlength: "); + output.append(length); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SoftwareDiagnosticsClusterSoftwareFaultStruct { + public Long id; + public String name; + public byte[] faultRecording; + + public SoftwareDiagnosticsClusterSoftwareFaultStruct( + Long id, String name, byte[] faultRecording) { + this.id = id; + this.name = name; + this.faultRecording = faultRecording; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SoftwareDiagnosticsClusterSoftwareFaultStruct {\n"); + output.append("\tid: "); + output.append(id); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tfaultRecording: "); + output.append(Arrays.toString(faultRecording)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SoftwareDiagnosticsClusterThreadMetrics { + public Long id; + public String name; + public Long stackFreeCurrent; + public Long stackFreeMinimum; + public Long stackSize; + + public SoftwareDiagnosticsClusterThreadMetrics( + Long id, String name, Long stackFreeCurrent, Long stackFreeMinimum, Long stackSize) { + this.id = id; + this.name = name; + this.stackFreeCurrent = stackFreeCurrent; + this.stackFreeMinimum = stackFreeMinimum; + this.stackSize = stackSize; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SoftwareDiagnosticsClusterThreadMetrics {\n"); + output.append("\tid: "); + output.append(id); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tstackFreeCurrent: "); + output.append(stackFreeCurrent); + output.append("\n"); + output.append("\tstackFreeMinimum: "); + output.append(stackFreeMinimum); + output.append("\n"); + output.append("\tstackSize: "); + output.append(stackSize); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TargetNavigatorClusterTargetInfo { + public Integer identifier; + public String name; + + public TargetNavigatorClusterTargetInfo(Integer identifier, String name) { + this.identifier = identifier; + this.name = name; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TargetNavigatorClusterTargetInfo {\n"); + output.append("\tidentifier: "); + output.append(identifier); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterSimpleStruct { + public Integer a; + public Boolean b; + public Integer c; + public byte[] d; + public String e; + public Integer f; + public Float g; + public Double h; + + public TestClusterClusterSimpleStruct( + Integer a, Boolean b, Integer c, byte[] d, String e, Integer f, Float g, Double h) { + this.a = a; + this.b = b; + this.c = c; + this.d = d; + this.e = e; + this.f = f; + this.g = g; + this.h = h; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterSimpleStruct {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("\td: "); + output.append(Arrays.toString(d)); + output.append("\n"); + output.append("\te: "); + output.append(e); + output.append("\n"); + output.append("\tf: "); + output.append(f); + output.append("\n"); + output.append("\tg: "); + output.append(g); + output.append("\n"); + output.append("\th: "); + output.append(h); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterNullablesAndOptionalsStruct { + public @Nullable Integer nullableInt; + public Optional optionalInt; + public @Nullable Optional nullableOptionalInt; + public @Nullable String nullableString; + public Optional optionalString; + public @Nullable Optional nullableOptionalString; + public @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct; + public Optional optionalStruct; + public @Nullable Optional nullableOptionalStruct; + public @Nullable ArrayList nullableList; + public Optional> optionalList; + public @Nullable Optional> nullableOptionalList; + + public TestClusterClusterNullablesAndOptionalsStruct( + @Nullable Integer nullableInt, + Optional optionalInt, + @Nullable Optional nullableOptionalInt, + @Nullable String nullableString, + Optional optionalString, + @Nullable Optional nullableOptionalString, + @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct, + Optional optionalStruct, + @Nullable Optional nullableOptionalStruct, + @Nullable ArrayList nullableList, + Optional> optionalList, + @Nullable Optional> nullableOptionalList) { + this.nullableInt = nullableInt; + this.optionalInt = optionalInt; + this.nullableOptionalInt = nullableOptionalInt; + this.nullableString = nullableString; + this.optionalString = optionalString; + this.nullableOptionalString = nullableOptionalString; + this.nullableStruct = nullableStruct; + this.optionalStruct = optionalStruct; + this.nullableOptionalStruct = nullableOptionalStruct; + this.nullableList = nullableList; + this.optionalList = optionalList; + this.nullableOptionalList = nullableOptionalList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNullablesAndOptionalsStruct {\n"); + output.append("\tnullableInt: "); + output.append(nullableInt); + output.append("\n"); + output.append("\toptionalInt: "); + output.append(optionalInt); + output.append("\n"); + output.append("\tnullableOptionalInt: "); + output.append(nullableOptionalInt); + output.append("\n"); + output.append("\tnullableString: "); + output.append(nullableString); + output.append("\n"); + output.append("\toptionalString: "); + output.append(optionalString); + output.append("\n"); + output.append("\tnullableOptionalString: "); + output.append(nullableOptionalString); + output.append("\n"); + output.append("\tnullableStruct: "); + output.append(nullableStruct); + output.append("\n"); + output.append("\toptionalStruct: "); + output.append(optionalStruct); + output.append("\n"); + output.append("\tnullableOptionalStruct: "); + output.append(nullableOptionalStruct); + output.append("\n"); + output.append("\tnullableList: "); + output.append(nullableList); + output.append("\n"); + output.append("\toptionalList: "); + output.append(optionalList); + output.append("\n"); + output.append("\tnullableOptionalList: "); + output.append(nullableOptionalList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterNestedStruct { + public Integer a; + public Boolean b; + public ChipStructs.TestClusterClusterSimpleStruct c; + + public TestClusterClusterNestedStruct( + Integer a, Boolean b, ChipStructs.TestClusterClusterSimpleStruct c) { + this.a = a; + this.b = b; + this.c = c; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNestedStruct {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterNestedStructList { + public Integer a; + public Boolean b; + public ChipStructs.TestClusterClusterSimpleStruct c; + public ArrayList d; + public ArrayList e; + public ArrayList f; + public ArrayList g; + + public TestClusterClusterNestedStructList( + Integer a, + Boolean b, + ChipStructs.TestClusterClusterSimpleStruct c, + ArrayList d, + ArrayList e, + ArrayList f, + ArrayList g) { + this.a = a; + this.b = b; + this.c = c; + this.d = d; + this.e = e; + this.f = f; + this.g = g; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNestedStructList {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("\td: "); + output.append(d); + output.append("\n"); + output.append("\te: "); + output.append(e); + output.append("\n"); + output.append("\tf: "); + output.append(f); + output.append("\n"); + output.append("\tg: "); + output.append(g); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterDoubleNestedStructList { + public ArrayList a; + + public TestClusterClusterDoubleNestedStructList( + ArrayList a) { + this.a = a; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterDoubleNestedStructList {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterTestFabricScoped { + public Integer fabricIndex; + + public TestClusterClusterTestFabricScoped(Integer fabricIndex) { + this.fabricIndex = fabricIndex; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterTestFabricScoped {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterTestListStructOctet { + public Long fabricIndex; + public byte[] operationalCert; + + public TestClusterClusterTestListStructOctet(Long fabricIndex, byte[] operationalCert) { + this.fabricIndex = fabricIndex; + this.operationalCert = operationalCert; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterTestListStructOctet {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\toperationalCert: "); + output.append(Arrays.toString(operationalCert)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterNeighborTable { + public Long extAddress; + public Long age; + public Integer rloc16; + public Long linkFrameCounter; + public Long mleFrameCounter; + public Integer lqi; + public Integer averageRssi; + public Integer lastRssi; + public Integer frameErrorRate; + public Integer messageErrorRate; + public Boolean rxOnWhenIdle; + public Boolean fullThreadDevice; + public Boolean fullNetworkData; + public Boolean isChild; + + public ThreadNetworkDiagnosticsClusterNeighborTable( + Long extAddress, + Long age, + Integer rloc16, + Long linkFrameCounter, + Long mleFrameCounter, + Integer lqi, + Integer averageRssi, + Integer lastRssi, + Integer frameErrorRate, + Integer messageErrorRate, + Boolean rxOnWhenIdle, + Boolean fullThreadDevice, + Boolean fullNetworkData, + Boolean isChild) { + this.extAddress = extAddress; + this.age = age; + this.rloc16 = rloc16; + this.linkFrameCounter = linkFrameCounter; + this.mleFrameCounter = mleFrameCounter; + this.lqi = lqi; + this.averageRssi = averageRssi; + this.lastRssi = lastRssi; + this.frameErrorRate = frameErrorRate; + this.messageErrorRate = messageErrorRate; + this.rxOnWhenIdle = rxOnWhenIdle; + this.fullThreadDevice = fullThreadDevice; + this.fullNetworkData = fullNetworkData; + this.isChild = isChild; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterNeighborTable {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\tage: "); + output.append(age); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\tlinkFrameCounter: "); + output.append(linkFrameCounter); + output.append("\n"); + output.append("\tmleFrameCounter: "); + output.append(mleFrameCounter); + output.append("\n"); + output.append("\tlqi: "); + output.append(lqi); + output.append("\n"); + output.append("\taverageRssi: "); + output.append(averageRssi); + output.append("\n"); + output.append("\tlastRssi: "); + output.append(lastRssi); + output.append("\n"); + output.append("\tframeErrorRate: "); + output.append(frameErrorRate); + output.append("\n"); + output.append("\tmessageErrorRate: "); + output.append(messageErrorRate); + output.append("\n"); + output.append("\trxOnWhenIdle: "); + output.append(rxOnWhenIdle); + output.append("\n"); + output.append("\tfullThreadDevice: "); + output.append(fullThreadDevice); + output.append("\n"); + output.append("\tfullNetworkData: "); + output.append(fullNetworkData); + output.append("\n"); + output.append("\tisChild: "); + output.append(isChild); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterOperationalDatasetComponents { + public Boolean activeTimestampPresent; + public Boolean pendingTimestampPresent; + public Boolean masterKeyPresent; + public Boolean networkNamePresent; + public Boolean extendedPanIdPresent; + public Boolean meshLocalPrefixPresent; + public Boolean delayPresent; + public Boolean panIdPresent; + public Boolean channelPresent; + public Boolean pskcPresent; + public Boolean securityPolicyPresent; + public Boolean channelMaskPresent; + + public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents( + Boolean activeTimestampPresent, + Boolean pendingTimestampPresent, + Boolean masterKeyPresent, + Boolean networkNamePresent, + Boolean extendedPanIdPresent, + Boolean meshLocalPrefixPresent, + Boolean delayPresent, + Boolean panIdPresent, + Boolean channelPresent, + Boolean pskcPresent, + Boolean securityPolicyPresent, + Boolean channelMaskPresent) { + this.activeTimestampPresent = activeTimestampPresent; + this.pendingTimestampPresent = pendingTimestampPresent; + this.masterKeyPresent = masterKeyPresent; + this.networkNamePresent = networkNamePresent; + this.extendedPanIdPresent = extendedPanIdPresent; + this.meshLocalPrefixPresent = meshLocalPrefixPresent; + this.delayPresent = delayPresent; + this.panIdPresent = panIdPresent; + this.channelPresent = channelPresent; + this.pskcPresent = pskcPresent; + this.securityPolicyPresent = securityPolicyPresent; + this.channelMaskPresent = channelMaskPresent; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterOperationalDatasetComponents {\n"); + output.append("\tactiveTimestampPresent: "); + output.append(activeTimestampPresent); + output.append("\n"); + output.append("\tpendingTimestampPresent: "); + output.append(pendingTimestampPresent); + output.append("\n"); + output.append("\tmasterKeyPresent: "); + output.append(masterKeyPresent); + output.append("\n"); + output.append("\tnetworkNamePresent: "); + output.append(networkNamePresent); + output.append("\n"); + output.append("\textendedPanIdPresent: "); + output.append(extendedPanIdPresent); + output.append("\n"); + output.append("\tmeshLocalPrefixPresent: "); + output.append(meshLocalPrefixPresent); + output.append("\n"); + output.append("\tdelayPresent: "); + output.append(delayPresent); + output.append("\n"); + output.append("\tpanIdPresent: "); + output.append(panIdPresent); + output.append("\n"); + output.append("\tchannelPresent: "); + output.append(channelPresent); + output.append("\n"); + output.append("\tpskcPresent: "); + output.append(pskcPresent); + output.append("\n"); + output.append("\tsecurityPolicyPresent: "); + output.append(securityPolicyPresent); + output.append("\n"); + output.append("\tchannelMaskPresent: "); + output.append(channelMaskPresent); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterRouteTable { + public Long extAddress; + public Integer rloc16; + public Integer routerId; + public Integer nextHop; + public Integer pathCost; + public Integer LQIIn; + public Integer LQIOut; + public Integer age; + public Boolean allocated; + public Boolean linkEstablished; + + public ThreadNetworkDiagnosticsClusterRouteTable( + Long extAddress, + Integer rloc16, + Integer routerId, + Integer nextHop, + Integer pathCost, + Integer LQIIn, + Integer LQIOut, + Integer age, + Boolean allocated, + Boolean linkEstablished) { + this.extAddress = extAddress; + this.rloc16 = rloc16; + this.routerId = routerId; + this.nextHop = nextHop; + this.pathCost = pathCost; + this.LQIIn = LQIIn; + this.LQIOut = LQIOut; + this.age = age; + this.allocated = allocated; + this.linkEstablished = linkEstablished; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterRouteTable {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\trouterId: "); + output.append(routerId); + output.append("\n"); + output.append("\tnextHop: "); + output.append(nextHop); + output.append("\n"); + output.append("\tpathCost: "); + output.append(pathCost); + output.append("\n"); + output.append("\tLQIIn: "); + output.append(LQIIn); + output.append("\n"); + output.append("\tLQIOut: "); + output.append(LQIOut); + output.append("\n"); + output.append("\tage: "); + output.append(age); + output.append("\n"); + output.append("\tallocated: "); + output.append(allocated); + output.append("\n"); + output.append("\tlinkEstablished: "); + output.append(linkEstablished); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterSecurityPolicy { + public Integer rotationTime; + public Integer flags; + + public ThreadNetworkDiagnosticsClusterSecurityPolicy(Integer rotationTime, Integer flags) { + this.rotationTime = rotationTime; + this.flags = flags; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterSecurityPolicy {\n"); + output.append("\trotationTime: "); + output.append(rotationTime); + output.append("\n"); + output.append("\tflags: "); + output.append(flags); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class UserLabelClusterLabelStruct { + public String label; + public String value; + + public UserLabelClusterLabelStruct(String label, String value) { + this.label = label; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("UserLabelClusterLabelStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterTarget {\n"); - output.append("\tcluster: "); - output.append(cluster); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("\tdeviceType: "); - output.append(deviceType); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class AccessControlClusterAccessControlEntry { -public Integer fabricIndex; -public Integer privilege; -public Integer authMode; -public @Nullable ArrayList subjects; -public @Nullable ArrayList targets; - - public AccessControlClusterAccessControlEntry( - Integer fabricIndex - , Integer privilege - , Integer authMode - , @Nullable ArrayList subjects - , @Nullable ArrayList targets - ) { - this.fabricIndex = fabricIndex; - this.privilege = privilege; - this.authMode = authMode; - this.subjects = subjects; - this.targets = targets; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterAccessControlEntry {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tprivilege: "); - output.append(privilege); - output.append("\n"); - output.append("\tauthMode: "); - output.append(authMode); - output.append("\n"); - output.append("\tsubjects: "); - output.append(subjects); - output.append("\n"); - output.append("\ttargets: "); - output.append(targets); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class AccessControlClusterExtensionEntry { -public Integer fabricIndex; -public byte[] data; - - public AccessControlClusterExtensionEntry( - Integer fabricIndex - , byte[] data - ) { - this.fabricIndex = fabricIndex; - this.data = data; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterExtensionEntry {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tdata: "); - output.append(Arrays.toString(data)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ApplicationBasicClusterApplicationBasicApplication { -public Integer catalogVendorId; -public String applicationId; - - public ApplicationBasicClusterApplicationBasicApplication( - Integer catalogVendorId - , String applicationId - ) { - this.catalogVendorId = catalogVendorId; - this.applicationId = applicationId; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationBasicClusterApplicationBasicApplication {\n"); - output.append("\tcatalogVendorId: "); - output.append(catalogVendorId); - output.append("\n"); - output.append("\tapplicationId: "); - output.append(applicationId); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ApplicationLauncherClusterApplicationLauncherApplication { -public Integer catalogVendorId; -public String applicationId; - - public ApplicationLauncherClusterApplicationLauncherApplication( - Integer catalogVendorId - , String applicationId - ) { - this.catalogVendorId = catalogVendorId; - this.applicationId = applicationId; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationLauncherClusterApplicationLauncherApplication {\n"); - output.append("\tcatalogVendorId: "); - output.append(catalogVendorId); - output.append("\n"); - output.append("\tapplicationId: "); - output.append(applicationId); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ApplicationLauncherClusterApplicationEP { -public ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application; -public String endpoint; - - public ApplicationLauncherClusterApplicationEP( - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , String endpoint - ) { - this.application = application; - this.endpoint = endpoint; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationLauncherClusterApplicationEP {\n"); - output.append("\tapplication: "); - output.append(application); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class AudioOutputClusterOutputInfo { -public Integer index; -public Integer outputType; -public String name; - - public AudioOutputClusterOutputInfo( - Integer index - , Integer outputType - , String name - ) { - this.index = index; - this.outputType = outputType; - this.name = name; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AudioOutputClusterOutputInfo {\n"); - output.append("\tindex: "); - output.append(index); - output.append("\n"); - output.append("\toutputType: "); - output.append(outputType); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class BridgedActionsClusterActionStruct { -public Integer actionID; -public String name; -public Integer type; -public Integer endpointListID; -public Integer supportedCommands; -public Integer status; - - public BridgedActionsClusterActionStruct( - Integer actionID - , String name - , Integer type - , Integer endpointListID - , Integer supportedCommands - , Integer status - ) { - this.actionID = actionID; - this.name = name; - this.type = type; - this.endpointListID = endpointListID; - this.supportedCommands = supportedCommands; - this.status = status; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedActionsClusterActionStruct {\n"); - output.append("\tactionID: "); - output.append(actionID); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tendpointListID: "); - output.append(endpointListID); - output.append("\n"); - output.append("\tsupportedCommands: "); - output.append(supportedCommands); - output.append("\n"); - output.append("\tstatus: "); - output.append(status); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class BridgedActionsClusterEndpointListStruct { -public Integer endpointListID; -public String name; -public Integer type; -public ArrayList endpoints; - - public BridgedActionsClusterEndpointListStruct( - Integer endpointListID - , String name - , Integer type - , ArrayList endpoints - ) { - this.endpointListID = endpointListID; - this.name = name; - this.type = type; - this.endpoints = endpoints; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedActionsClusterEndpointListStruct {\n"); - output.append("\tendpointListID: "); - output.append(endpointListID); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tendpoints: "); - output.append(endpoints); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ChannelClusterChannelInfo { -public Integer majorNumber; -public Integer minorNumber; -public String name; -public String callSign; -public String affiliateCallSign; - - public ChannelClusterChannelInfo( - Integer majorNumber - , Integer minorNumber - , String name - , String callSign - , String affiliateCallSign - ) { - this.majorNumber = majorNumber; - this.minorNumber = minorNumber; - this.name = name; - this.callSign = callSign; - this.affiliateCallSign = affiliateCallSign; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ChannelClusterChannelInfo {\n"); - output.append("\tmajorNumber: "); - output.append(majorNumber); - output.append("\n"); - output.append("\tminorNumber: "); - output.append(minorNumber); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tcallSign: "); - output.append(callSign); - output.append("\n"); - output.append("\taffiliateCallSign: "); - output.append(affiliateCallSign); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ChannelClusterLineupInfo { -public String operatorName; -public String lineupName; -public String postalCode; -public Integer lineupInfoType; - - public ChannelClusterLineupInfo( - String operatorName - , String lineupName - , String postalCode - , Integer lineupInfoType - ) { - this.operatorName = operatorName; - this.lineupName = lineupName; - this.postalCode = postalCode; - this.lineupInfoType = lineupInfoType; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ChannelClusterLineupInfo {\n"); - output.append("\toperatorName: "); - output.append(operatorName); - output.append("\n"); - output.append("\tlineupName: "); - output.append(lineupName); - output.append("\n"); - output.append("\tpostalCode: "); - output.append(postalCode); - output.append("\n"); - output.append("\tlineupInfoType: "); - output.append(lineupInfoType); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterDimension { -public Double width; -public Double height; -public Integer metric; - - public ContentLauncherClusterDimension( - Double width - , Double height - , Integer metric - ) { - this.width = width; - this.height = height; - this.metric = metric; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterDimension {\n"); - output.append("\twidth: "); - output.append(width); - output.append("\n"); - output.append("\theight: "); - output.append(height); - output.append("\n"); - output.append("\tmetric: "); - output.append(metric); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterAdditionalInfo { -public String name; -public String value; - - public ContentLauncherClusterAdditionalInfo( - String name - , String value - ) { - this.name = name; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterAdditionalInfo {\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterParameter { -public Integer type; -public String value; -public ArrayList externalIDList; - - public ContentLauncherClusterParameter( - Integer type - , String value - , ArrayList externalIDList - ) { - this.type = type; - this.value = value; - this.externalIDList = externalIDList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterParameter {\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("\texternalIDList: "); - output.append(externalIDList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterContentSearch { -public ArrayList parameterList; - - public ContentLauncherClusterContentSearch( - ArrayList parameterList - ) { - this.parameterList = parameterList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterContentSearch {\n"); - output.append("\tparameterList: "); - output.append(parameterList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterStyleInformation { -public String imageUrl; -public String color; -public ChipStructs.ContentLauncherClusterDimension size; - - public ContentLauncherClusterStyleInformation( - String imageUrl - , String color - , ChipStructs.ContentLauncherClusterDimension size - ) { - this.imageUrl = imageUrl; - this.color = color; - this.size = size; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterStyleInformation {\n"); - output.append("\timageUrl: "); - output.append(imageUrl); - output.append("\n"); - output.append("\tcolor: "); - output.append(color); - output.append("\n"); - output.append("\tsize: "); - output.append(size); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterBrandingInformation { -public String providerName; -public ChipStructs.ContentLauncherClusterStyleInformation background; -public ChipStructs.ContentLauncherClusterStyleInformation logo; -public ChipStructs.ContentLauncherClusterStyleInformation progressBar; -public ChipStructs.ContentLauncherClusterStyleInformation splash; -public ChipStructs.ContentLauncherClusterStyleInformation waterMark; - - public ContentLauncherClusterBrandingInformation( - String providerName - , ChipStructs.ContentLauncherClusterStyleInformation background - , ChipStructs.ContentLauncherClusterStyleInformation logo - , ChipStructs.ContentLauncherClusterStyleInformation progressBar - , ChipStructs.ContentLauncherClusterStyleInformation splash - , ChipStructs.ContentLauncherClusterStyleInformation waterMark - ) { - this.providerName = providerName; - this.background = background; - this.logo = logo; - this.progressBar = progressBar; - this.splash = splash; - this.waterMark = waterMark; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterBrandingInformation {\n"); - output.append("\tproviderName: "); - output.append(providerName); - output.append("\n"); - output.append("\tbackground: "); - output.append(background); - output.append("\n"); - output.append("\tlogo: "); - output.append(logo); - output.append("\n"); - output.append("\tprogressBar: "); - output.append(progressBar); - output.append("\n"); - output.append("\tsplash: "); - output.append(splash); - output.append("\n"); - output.append("\twaterMark: "); - output.append(waterMark); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class DescriptorClusterDeviceType { -public Long type; -public Integer revision; - - public DescriptorClusterDeviceType( - Long type - , Integer revision - ) { - this.type = type; - this.revision = revision; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DescriptorClusterDeviceType {\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\trevision: "); - output.append(revision); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class DoorLockClusterDlCredential { -public Integer credentialType; -public Integer credentialIndex; - - public DoorLockClusterDlCredential( - Integer credentialType - , Integer credentialIndex - ) { - this.credentialType = credentialType; - this.credentialIndex = credentialIndex; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DoorLockClusterDlCredential {\n"); - output.append("\tcredentialType: "); - output.append(credentialType); - output.append("\n"); - output.append("\tcredentialIndex: "); - output.append(credentialIndex); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class FixedLabelClusterLabelStruct { -public String label; -public String value; - - public FixedLabelClusterLabelStruct( - String label - , String value - ) { - this.label = label; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("FixedLabelClusterLabelStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GeneralCommissioningClusterBasicCommissioningInfoType { -public Long failSafeExpiryLengthMs; - - public GeneralCommissioningClusterBasicCommissioningInfoType( - Long failSafeExpiryLengthMs - ) { - this.failSafeExpiryLengthMs = failSafeExpiryLengthMs; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GeneralCommissioningClusterBasicCommissioningInfoType {\n"); - output.append("\tfailSafeExpiryLengthMs: "); - output.append(failSafeExpiryLengthMs); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GeneralDiagnosticsClusterNetworkInterfaceType { -public String name; -public Boolean fabricConnected; -public Boolean offPremiseServicesReachableIPv4; -public Boolean offPremiseServicesReachableIPv6; -public byte[] hardwareAddress; -public Integer type; - - public GeneralDiagnosticsClusterNetworkInterfaceType( - String name - , Boolean fabricConnected - , Boolean offPremiseServicesReachableIPv4 - , Boolean offPremiseServicesReachableIPv6 - , byte[] hardwareAddress - , Integer type - ) { - this.name = name; - this.fabricConnected = fabricConnected; - this.offPremiseServicesReachableIPv4 = offPremiseServicesReachableIPv4; - this.offPremiseServicesReachableIPv6 = offPremiseServicesReachableIPv6; - this.hardwareAddress = hardwareAddress; - this.type = type; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GeneralDiagnosticsClusterNetworkInterfaceType {\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tfabricConnected: "); - output.append(fabricConnected); - output.append("\n"); - output.append("\toffPremiseServicesReachableIPv4: "); - output.append(offPremiseServicesReachableIPv4); - output.append("\n"); - output.append("\toffPremiseServicesReachableIPv6: "); - output.append(offPremiseServicesReachableIPv6); - output.append("\n"); - output.append("\thardwareAddress: "); - output.append(Arrays.toString(hardwareAddress)); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GroupKeyManagementClusterGroupInfo { -public Integer fabricIndex; -public Integer groupId; -public ArrayList endpoints; -public String groupName; - - public GroupKeyManagementClusterGroupInfo( - Integer fabricIndex - , Integer groupId - , ArrayList endpoints - , String groupName - ) { - this.fabricIndex = fabricIndex; - this.groupId = groupId; - this.endpoints = endpoints; - this.groupName = groupName; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupInfo {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tgroupId: "); - output.append(groupId); - output.append("\n"); - output.append("\tendpoints: "); - output.append(endpoints); - output.append("\n"); - output.append("\tgroupName: "); - output.append(groupName); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GroupKeyManagementClusterGroupKey { -public Integer fabricIndex; -public Integer groupId; -public Integer groupKeySetID; - - public GroupKeyManagementClusterGroupKey( - Integer fabricIndex - , Integer groupId - , Integer groupKeySetID - ) { - this.fabricIndex = fabricIndex; - this.groupId = groupId; - this.groupKeySetID = groupKeySetID; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupKey {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tgroupId: "); - output.append(groupId); - output.append("\n"); - output.append("\tgroupKeySetID: "); - output.append(groupKeySetID); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GroupKeyManagementClusterGroupKeySet { -public Integer groupKeySetID; -public Integer securityPolicy; -public byte[] epochKey0; -public Long epochStartTime0; -public byte[] epochKey1; -public Long epochStartTime1; -public byte[] epochKey2; -public Long epochStartTime2; - - public GroupKeyManagementClusterGroupKeySet( - Integer groupKeySetID - , Integer securityPolicy - , byte[] epochKey0 - , Long epochStartTime0 - , byte[] epochKey1 - , Long epochStartTime1 - , byte[] epochKey2 - , Long epochStartTime2 - ) { - this.groupKeySetID = groupKeySetID; - this.securityPolicy = securityPolicy; - this.epochKey0 = epochKey0; - this.epochStartTime0 = epochStartTime0; - this.epochKey1 = epochKey1; - this.epochStartTime1 = epochStartTime1; - this.epochKey2 = epochKey2; - this.epochStartTime2 = epochStartTime2; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupKeySet {\n"); - output.append("\tgroupKeySetID: "); - output.append(groupKeySetID); - output.append("\n"); - output.append("\tsecurityPolicy: "); - output.append(securityPolicy); - output.append("\n"); - output.append("\tepochKey0: "); - output.append(Arrays.toString(epochKey0)); - output.append("\n"); - output.append("\tepochStartTime0: "); - output.append(epochStartTime0); - output.append("\n"); - output.append("\tepochKey1: "); - output.append(Arrays.toString(epochKey1)); - output.append("\n"); - output.append("\tepochStartTime1: "); - output.append(epochStartTime1); - output.append("\n"); - output.append("\tepochKey2: "); - output.append(Arrays.toString(epochKey2)); - output.append("\n"); - output.append("\tepochStartTime2: "); - output.append(epochStartTime2); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class MediaInputClusterInputInfo { -public Integer index; -public Integer inputType; -public String name; -public String description; - - public MediaInputClusterInputInfo( - Integer index - , Integer inputType - , String name - , String description - ) { - this.index = index; - this.inputType = inputType; - this.name = name; - this.description = description; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("MediaInputClusterInputInfo {\n"); - output.append("\tindex: "); - output.append(index); - output.append("\n"); - output.append("\tinputType: "); - output.append(inputType); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tdescription: "); - output.append(description); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class MediaPlaybackClusterPlaybackPosition { -public Long updatedAt; -public Long position; - - public MediaPlaybackClusterPlaybackPosition( - Long updatedAt - , Long position - ) { - this.updatedAt = updatedAt; - this.position = position; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("MediaPlaybackClusterPlaybackPosition {\n"); - output.append("\tupdatedAt: "); - output.append(updatedAt); - output.append("\n"); - output.append("\tposition: "); - output.append(position); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ModeSelectClusterModeOptionStruct { -public String label; -public Integer mode; -public Long semanticTag; - - public ModeSelectClusterModeOptionStruct( - String label - , Integer mode - , Long semanticTag - ) { - this.label = label; - this.mode = mode; - this.semanticTag = semanticTag; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ModeSelectClusterModeOptionStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tmode: "); - output.append(mode); - output.append("\n"); - output.append("\tsemanticTag: "); - output.append(semanticTag); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ModeSelectClusterSemanticTag { -public Integer mfgCode; -public Integer value; - - public ModeSelectClusterSemanticTag( - Integer mfgCode - , Integer value - ) { - this.mfgCode = mfgCode; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ModeSelectClusterSemanticTag {\n"); - output.append("\tmfgCode: "); - output.append(mfgCode); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class NetworkCommissioningClusterNetworkInfo { -public byte[] networkID; -public Boolean connected; - - public NetworkCommissioningClusterNetworkInfo( - byte[] networkID - , Boolean connected - ) { - this.networkID = networkID; - this.connected = connected; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterNetworkInfo {\n"); - output.append("\tnetworkID: "); - output.append(Arrays.toString(networkID)); - output.append("\n"); - output.append("\tconnected: "); - output.append(connected); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class NetworkCommissioningClusterThreadInterfaceScanResult { -public Long panId; -public Long extendedPanId; -public String networkName; -public Integer channel; -public Integer version; -public Long extendedAddress; -public Integer rssi; -public Integer lqi; - - public NetworkCommissioningClusterThreadInterfaceScanResult( - Long panId - , Long extendedPanId - , String networkName - , Integer channel - , Integer version - , Long extendedAddress - , Integer rssi - , Integer lqi - ) { - this.panId = panId; - this.extendedPanId = extendedPanId; - this.networkName = networkName; - this.channel = channel; - this.version = version; - this.extendedAddress = extendedAddress; - this.rssi = rssi; - this.lqi = lqi; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterThreadInterfaceScanResult {\n"); - output.append("\tpanId: "); - output.append(panId); - output.append("\n"); - output.append("\textendedPanId: "); - output.append(extendedPanId); - output.append("\n"); - output.append("\tnetworkName: "); - output.append(networkName); - output.append("\n"); - output.append("\tchannel: "); - output.append(channel); - output.append("\n"); - output.append("\tversion: "); - output.append(version); - output.append("\n"); - output.append("\textendedAddress: "); - output.append(extendedAddress); - output.append("\n"); - output.append("\trssi: "); - output.append(rssi); - output.append("\n"); - output.append("\tlqi: "); - output.append(lqi); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class NetworkCommissioningClusterWiFiInterfaceScanResult { -public Integer security; -public byte[] ssid; -public byte[] bssid; -public Integer channel; -public Integer wiFiBand; -public Integer rssi; - - public NetworkCommissioningClusterWiFiInterfaceScanResult( - Integer security - , byte[] ssid - , byte[] bssid - , Integer channel - , Integer wiFiBand - , Integer rssi - ) { - this.security = security; - this.ssid = ssid; - this.bssid = bssid; - this.channel = channel; - this.wiFiBand = wiFiBand; - this.rssi = rssi; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterWiFiInterfaceScanResult {\n"); - output.append("\tsecurity: "); - output.append(security); - output.append("\n"); - output.append("\tssid: "); - output.append(Arrays.toString(ssid)); - output.append("\n"); - output.append("\tbssid: "); - output.append(Arrays.toString(bssid)); - output.append("\n"); - output.append("\tchannel: "); - output.append(channel); - output.append("\n"); - output.append("\twiFiBand: "); - output.append(wiFiBand); - output.append("\n"); - output.append("\trssi: "); - output.append(rssi); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class OtaSoftwareUpdateRequestorClusterProviderLocation { -public Integer fabricIndex; -public Long providerNodeID; -public Integer endpoint; - - public OtaSoftwareUpdateRequestorClusterProviderLocation( - Integer fabricIndex - , Long providerNodeID - , Integer endpoint - ) { - this.fabricIndex = fabricIndex; - this.providerNodeID = providerNodeID; - this.endpoint = endpoint; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OtaSoftwareUpdateRequestorClusterProviderLocation {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tproviderNodeID: "); - output.append(providerNodeID); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class OperationalCredentialsClusterFabricDescriptor { -public Integer fabricIndex; -public byte[] rootPublicKey; -public Integer vendorId; -public Long fabricId; -public Long nodeId; -public String label; - - public OperationalCredentialsClusterFabricDescriptor( - Integer fabricIndex - , byte[] rootPublicKey - , Integer vendorId - , Long fabricId - , Long nodeId - , String label - ) { - this.fabricIndex = fabricIndex; - this.rootPublicKey = rootPublicKey; - this.vendorId = vendorId; - this.fabricId = fabricId; - this.nodeId = nodeId; - this.label = label; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OperationalCredentialsClusterFabricDescriptor {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\trootPublicKey: "); - output.append(Arrays.toString(rootPublicKey)); - output.append("\n"); - output.append("\tvendorId: "); - output.append(vendorId); - output.append("\n"); - output.append("\tfabricId: "); - output.append(fabricId); - output.append("\n"); - output.append("\tnodeId: "); - output.append(nodeId); - output.append("\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class OperationalCredentialsClusterNOCStruct { -public Integer fabricIndex; -public byte[] noc; -public @Nullable byte[] icac; - - public OperationalCredentialsClusterNOCStruct( - Integer fabricIndex - , byte[] noc - , @Nullable byte[] icac - ) { - this.fabricIndex = fabricIndex; - this.noc = noc; - this.icac = icac; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OperationalCredentialsClusterNOCStruct {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tnoc: "); - output.append(Arrays.toString(noc)); - output.append("\n"); - output.append("\ticac: "); - output.append(Arrays.toString(icac)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class PowerSourceClusterBatChargeFaultChangeType { -public ArrayList current; -public ArrayList previous; - - public PowerSourceClusterBatChargeFaultChangeType( - ArrayList current - , ArrayList previous - ) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterBatChargeFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class PowerSourceClusterBatFaultChangeType { -public ArrayList current; -public ArrayList previous; - - public PowerSourceClusterBatFaultChangeType( - ArrayList current - , ArrayList previous - ) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterBatFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class PowerSourceClusterWiredFaultChangeType { -public ArrayList current; -public ArrayList previous; - - public PowerSourceClusterWiredFaultChangeType( - ArrayList current - , ArrayList previous - ) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterWiredFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ScenesClusterSceneExtensionFieldSet { -public Long clusterId; -public Integer length; -public Integer value; - - public ScenesClusterSceneExtensionFieldSet( - Long clusterId - , Integer length - , Integer value - ) { - this.clusterId = clusterId; - this.length = length; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ScenesClusterSceneExtensionFieldSet {\n"); - output.append("\tclusterId: "); - output.append(clusterId); - output.append("\n"); - output.append("\tlength: "); - output.append(length); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class SoftwareDiagnosticsClusterSoftwareFaultStruct { -public Long id; -public String name; -public byte[] faultRecording; - - public SoftwareDiagnosticsClusterSoftwareFaultStruct( - Long id - , String name - , byte[] faultRecording - ) { - this.id = id; - this.name = name; - this.faultRecording = faultRecording; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SoftwareDiagnosticsClusterSoftwareFaultStruct {\n"); - output.append("\tid: "); - output.append(id); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tfaultRecording: "); - output.append(Arrays.toString(faultRecording)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class SoftwareDiagnosticsClusterThreadMetrics { -public Long id; -public String name; -public Long stackFreeCurrent; -public Long stackFreeMinimum; -public Long stackSize; - - public SoftwareDiagnosticsClusterThreadMetrics( - Long id - , String name - , Long stackFreeCurrent - , Long stackFreeMinimum - , Long stackSize - ) { - this.id = id; - this.name = name; - this.stackFreeCurrent = stackFreeCurrent; - this.stackFreeMinimum = stackFreeMinimum; - this.stackSize = stackSize; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SoftwareDiagnosticsClusterThreadMetrics {\n"); - output.append("\tid: "); - output.append(id); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tstackFreeCurrent: "); - output.append(stackFreeCurrent); - output.append("\n"); - output.append("\tstackFreeMinimum: "); - output.append(stackFreeMinimum); - output.append("\n"); - output.append("\tstackSize: "); - output.append(stackSize); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TargetNavigatorClusterTargetInfo { -public Integer identifier; -public String name; - - public TargetNavigatorClusterTargetInfo( - Integer identifier - , String name - ) { - this.identifier = identifier; - this.name = name; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TargetNavigatorClusterTargetInfo {\n"); - output.append("\tidentifier: "); - output.append(identifier); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterSimpleStruct { -public Integer a; -public Boolean b; -public Integer c; -public byte[] d; -public String e; -public Integer f; -public Float g; -public Double h; - - public TestClusterClusterSimpleStruct( - Integer a - , Boolean b - , Integer c - , byte[] d - , String e - , Integer f - , Float g - , Double h - ) { - this.a = a; - this.b = b; - this.c = c; - this.d = d; - this.e = e; - this.f = f; - this.g = g; - this.h = h; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterSimpleStruct {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("\td: "); - output.append(Arrays.toString(d)); - output.append("\n"); - output.append("\te: "); - output.append(e); - output.append("\n"); - output.append("\tf: "); - output.append(f); - output.append("\n"); - output.append("\tg: "); - output.append(g); - output.append("\n"); - output.append("\th: "); - output.append(h); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterNullablesAndOptionalsStruct { -public @Nullable Integer nullableInt; -public Optional optionalInt; -public @Nullable Optional nullableOptionalInt; -public @Nullable String nullableString; -public Optional optionalString; -public @Nullable Optional nullableOptionalString; -public @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct; -public Optional optionalStruct; -public @Nullable Optional nullableOptionalStruct; -public @Nullable ArrayList nullableList; -public Optional> optionalList; -public @Nullable Optional> nullableOptionalList; - - public TestClusterClusterNullablesAndOptionalsStruct( - @Nullable Integer nullableInt - , Optional optionalInt - , @Nullable Optional nullableOptionalInt - , @Nullable String nullableString - , Optional optionalString - , @Nullable Optional nullableOptionalString - , @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct - , Optional optionalStruct - , @Nullable Optional nullableOptionalStruct - , @Nullable ArrayList nullableList - , Optional> optionalList - , @Nullable Optional> nullableOptionalList - ) { - this.nullableInt = nullableInt; - this.optionalInt = optionalInt; - this.nullableOptionalInt = nullableOptionalInt; - this.nullableString = nullableString; - this.optionalString = optionalString; - this.nullableOptionalString = nullableOptionalString; - this.nullableStruct = nullableStruct; - this.optionalStruct = optionalStruct; - this.nullableOptionalStruct = nullableOptionalStruct; - this.nullableList = nullableList; - this.optionalList = optionalList; - this.nullableOptionalList = nullableOptionalList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNullablesAndOptionalsStruct {\n"); - output.append("\tnullableInt: "); - output.append(nullableInt); - output.append("\n"); - output.append("\toptionalInt: "); - output.append(optionalInt); - output.append("\n"); - output.append("\tnullableOptionalInt: "); - output.append(nullableOptionalInt); - output.append("\n"); - output.append("\tnullableString: "); - output.append(nullableString); - output.append("\n"); - output.append("\toptionalString: "); - output.append(optionalString); - output.append("\n"); - output.append("\tnullableOptionalString: "); - output.append(nullableOptionalString); - output.append("\n"); - output.append("\tnullableStruct: "); - output.append(nullableStruct); - output.append("\n"); - output.append("\toptionalStruct: "); - output.append(optionalStruct); - output.append("\n"); - output.append("\tnullableOptionalStruct: "); - output.append(nullableOptionalStruct); - output.append("\n"); - output.append("\tnullableList: "); - output.append(nullableList); - output.append("\n"); - output.append("\toptionalList: "); - output.append(optionalList); - output.append("\n"); - output.append("\tnullableOptionalList: "); - output.append(nullableOptionalList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterNestedStruct { -public Integer a; -public Boolean b; -public ChipStructs.TestClusterClusterSimpleStruct c; - - public TestClusterClusterNestedStruct( - Integer a - , Boolean b - , ChipStructs.TestClusterClusterSimpleStruct c - ) { - this.a = a; - this.b = b; - this.c = c; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNestedStruct {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterNestedStructList { -public Integer a; -public Boolean b; -public ChipStructs.TestClusterClusterSimpleStruct c; -public ArrayList d; -public ArrayList e; -public ArrayList f; -public ArrayList g; - - public TestClusterClusterNestedStructList( - Integer a - , Boolean b - , ChipStructs.TestClusterClusterSimpleStruct c - , ArrayList d - , ArrayList e - , ArrayList f - , ArrayList g - ) { - this.a = a; - this.b = b; - this.c = c; - this.d = d; - this.e = e; - this.f = f; - this.g = g; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNestedStructList {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("\td: "); - output.append(d); - output.append("\n"); - output.append("\te: "); - output.append(e); - output.append("\n"); - output.append("\tf: "); - output.append(f); - output.append("\n"); - output.append("\tg: "); - output.append(g); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterDoubleNestedStructList { -public ArrayList a; - - public TestClusterClusterDoubleNestedStructList( - ArrayList a - ) { - this.a = a; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterDoubleNestedStructList {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterTestFabricScoped { -public Integer fabricIndex; - - public TestClusterClusterTestFabricScoped( - Integer fabricIndex - ) { - this.fabricIndex = fabricIndex; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterTestFabricScoped {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterTestListStructOctet { -public Long fabricIndex; -public byte[] operationalCert; - - public TestClusterClusterTestListStructOctet( - Long fabricIndex - , byte[] operationalCert - ) { - this.fabricIndex = fabricIndex; - this.operationalCert = operationalCert; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterTestListStructOctet {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\toperationalCert: "); - output.append(Arrays.toString(operationalCert)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterNeighborTable { -public Long extAddress; -public Long age; -public Integer rloc16; -public Long linkFrameCounter; -public Long mleFrameCounter; -public Integer lqi; -public Integer averageRssi; -public Integer lastRssi; -public Integer frameErrorRate; -public Integer messageErrorRate; -public Boolean rxOnWhenIdle; -public Boolean fullThreadDevice; -public Boolean fullNetworkData; -public Boolean isChild; - - public ThreadNetworkDiagnosticsClusterNeighborTable( - Long extAddress - , Long age - , Integer rloc16 - , Long linkFrameCounter - , Long mleFrameCounter - , Integer lqi - , Integer averageRssi - , Integer lastRssi - , Integer frameErrorRate - , Integer messageErrorRate - , Boolean rxOnWhenIdle - , Boolean fullThreadDevice - , Boolean fullNetworkData - , Boolean isChild - ) { - this.extAddress = extAddress; - this.age = age; - this.rloc16 = rloc16; - this.linkFrameCounter = linkFrameCounter; - this.mleFrameCounter = mleFrameCounter; - this.lqi = lqi; - this.averageRssi = averageRssi; - this.lastRssi = lastRssi; - this.frameErrorRate = frameErrorRate; - this.messageErrorRate = messageErrorRate; - this.rxOnWhenIdle = rxOnWhenIdle; - this.fullThreadDevice = fullThreadDevice; - this.fullNetworkData = fullNetworkData; - this.isChild = isChild; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterNeighborTable {\n"); - output.append("\textAddress: "); - output.append(extAddress); - output.append("\n"); - output.append("\tage: "); - output.append(age); - output.append("\n"); - output.append("\trloc16: "); - output.append(rloc16); - output.append("\n"); - output.append("\tlinkFrameCounter: "); - output.append(linkFrameCounter); - output.append("\n"); - output.append("\tmleFrameCounter: "); - output.append(mleFrameCounter); - output.append("\n"); - output.append("\tlqi: "); - output.append(lqi); - output.append("\n"); - output.append("\taverageRssi: "); - output.append(averageRssi); - output.append("\n"); - output.append("\tlastRssi: "); - output.append(lastRssi); - output.append("\n"); - output.append("\tframeErrorRate: "); - output.append(frameErrorRate); - output.append("\n"); - output.append("\tmessageErrorRate: "); - output.append(messageErrorRate); - output.append("\n"); - output.append("\trxOnWhenIdle: "); - output.append(rxOnWhenIdle); - output.append("\n"); - output.append("\tfullThreadDevice: "); - output.append(fullThreadDevice); - output.append("\n"); - output.append("\tfullNetworkData: "); - output.append(fullNetworkData); - output.append("\n"); - output.append("\tisChild: "); - output.append(isChild); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterOperationalDatasetComponents { -public Boolean activeTimestampPresent; -public Boolean pendingTimestampPresent; -public Boolean masterKeyPresent; -public Boolean networkNamePresent; -public Boolean extendedPanIdPresent; -public Boolean meshLocalPrefixPresent; -public Boolean delayPresent; -public Boolean panIdPresent; -public Boolean channelPresent; -public Boolean pskcPresent; -public Boolean securityPolicyPresent; -public Boolean channelMaskPresent; - - public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents( - Boolean activeTimestampPresent - , Boolean pendingTimestampPresent - , Boolean masterKeyPresent - , Boolean networkNamePresent - , Boolean extendedPanIdPresent - , Boolean meshLocalPrefixPresent - , Boolean delayPresent - , Boolean panIdPresent - , Boolean channelPresent - , Boolean pskcPresent - , Boolean securityPolicyPresent - , Boolean channelMaskPresent - ) { - this.activeTimestampPresent = activeTimestampPresent; - this.pendingTimestampPresent = pendingTimestampPresent; - this.masterKeyPresent = masterKeyPresent; - this.networkNamePresent = networkNamePresent; - this.extendedPanIdPresent = extendedPanIdPresent; - this.meshLocalPrefixPresent = meshLocalPrefixPresent; - this.delayPresent = delayPresent; - this.panIdPresent = panIdPresent; - this.channelPresent = channelPresent; - this.pskcPresent = pskcPresent; - this.securityPolicyPresent = securityPolicyPresent; - this.channelMaskPresent = channelMaskPresent; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterOperationalDatasetComponents {\n"); - output.append("\tactiveTimestampPresent: "); - output.append(activeTimestampPresent); - output.append("\n"); - output.append("\tpendingTimestampPresent: "); - output.append(pendingTimestampPresent); - output.append("\n"); - output.append("\tmasterKeyPresent: "); - output.append(masterKeyPresent); - output.append("\n"); - output.append("\tnetworkNamePresent: "); - output.append(networkNamePresent); - output.append("\n"); - output.append("\textendedPanIdPresent: "); - output.append(extendedPanIdPresent); - output.append("\n"); - output.append("\tmeshLocalPrefixPresent: "); - output.append(meshLocalPrefixPresent); - output.append("\n"); - output.append("\tdelayPresent: "); - output.append(delayPresent); - output.append("\n"); - output.append("\tpanIdPresent: "); - output.append(panIdPresent); - output.append("\n"); - output.append("\tchannelPresent: "); - output.append(channelPresent); - output.append("\n"); - output.append("\tpskcPresent: "); - output.append(pskcPresent); - output.append("\n"); - output.append("\tsecurityPolicyPresent: "); - output.append(securityPolicyPresent); - output.append("\n"); - output.append("\tchannelMaskPresent: "); - output.append(channelMaskPresent); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterRouteTable { -public Long extAddress; -public Integer rloc16; -public Integer routerId; -public Integer nextHop; -public Integer pathCost; -public Integer LQIIn; -public Integer LQIOut; -public Integer age; -public Boolean allocated; -public Boolean linkEstablished; - - public ThreadNetworkDiagnosticsClusterRouteTable( - Long extAddress - , Integer rloc16 - , Integer routerId - , Integer nextHop - , Integer pathCost - , Integer LQIIn - , Integer LQIOut - , Integer age - , Boolean allocated - , Boolean linkEstablished - ) { - this.extAddress = extAddress; - this.rloc16 = rloc16; - this.routerId = routerId; - this.nextHop = nextHop; - this.pathCost = pathCost; - this.LQIIn = LQIIn; - this.LQIOut = LQIOut; - this.age = age; - this.allocated = allocated; - this.linkEstablished = linkEstablished; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterRouteTable {\n"); - output.append("\textAddress: "); - output.append(extAddress); - output.append("\n"); - output.append("\trloc16: "); - output.append(rloc16); - output.append("\n"); - output.append("\trouterId: "); - output.append(routerId); - output.append("\n"); - output.append("\tnextHop: "); - output.append(nextHop); - output.append("\n"); - output.append("\tpathCost: "); - output.append(pathCost); - output.append("\n"); - output.append("\tLQIIn: "); - output.append(LQIIn); - output.append("\n"); - output.append("\tLQIOut: "); - output.append(LQIOut); - output.append("\n"); - output.append("\tage: "); - output.append(age); - output.append("\n"); - output.append("\tallocated: "); - output.append(allocated); - output.append("\n"); - output.append("\tlinkEstablished: "); - output.append(linkEstablished); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterSecurityPolicy { -public Integer rotationTime; -public Integer flags; - - public ThreadNetworkDiagnosticsClusterSecurityPolicy( - Integer rotationTime - , Integer flags - ) { - this.rotationTime = rotationTime; - this.flags = flags; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterSecurityPolicy {\n"); - output.append("\trotationTime: "); - output.append(rotationTime); - output.append("\n"); - output.append("\tflags: "); - output.append(flags); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class UserLabelClusterLabelStruct { -public String label; -public String value; - - public UserLabelClusterLabelStruct( - String label - , String value - ) { - this.label = label; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("UserLabelClusterLabelStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index 36b3755afb50ea..8bead24d836255 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -20,26 +20,24 @@ package chip.devicecontroller; import androidx.annotation.Nullable; +import chip.clusterinfo.ClusterCommandCallback; +import chip.clusterinfo.ClusterInfo; +import chip.clusterinfo.CommandParameterInfo; +import chip.clusterinfo.CommandResponseInfo; +import chip.clusterinfo.DelegatedClusterCallback; +import chip.clusterinfo.InteractionInfo; +import chip.devicecontroller.ChipClusters.DefaultClusterCallback; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Optional; -import androidx.annotation.Nullable; -import chip.clusterinfo.ClusterInfo; -import chip.clusterinfo.InteractionInfo; -import chip.clusterinfo.CommandParameterInfo; -import chip.clusterinfo.DelegatedClusterCallback; -import chip.clusterinfo.ClusterCommandCallback; -import chip.clusterinfo.CommandResponseInfo; -import chip.devicecontroller.ChipClusters.DefaultClusterCallback; -import chip.devicecontroller.ClusterReadMapping; -import chip.devicecontroller.ClusterWriteMapping; public class ClusterInfoMapping { - public static class DelegatedCharStringAttributeCallback implements ChipClusters.CharStringAttributeCallback, DelegatedClusterCallback { + public static class DelegatedCharStringAttributeCallback + implements ChipClusters.CharStringAttributeCallback, DelegatedClusterCallback { /** Indicates a successful read for a CHAR_STRING attribute. */ private ClusterCommandCallback callback; @@ -62,7 +60,8 @@ public void onError(Exception error) { } } - public static class DelegatedOctetStringAttributeCallback implements ChipClusters.OctetStringAttributeCallback, DelegatedClusterCallback { + public static class DelegatedOctetStringAttributeCallback + implements ChipClusters.OctetStringAttributeCallback, DelegatedClusterCallback { /** Indicates a successful read for an OCTET_STRING attribute. */ private ClusterCommandCallback callback; @@ -85,7 +84,8 @@ public void onError(Exception error) { } } - public static class DelegatedIntegerAttributeCallback implements ChipClusters.IntegerAttributeCallback, DelegatedClusterCallback { + public static class DelegatedIntegerAttributeCallback + implements ChipClusters.IntegerAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -107,7 +107,8 @@ public void onError(Exception error) { } } - public static class DelegatedLongAttributeCallback implements ChipClusters.LongAttributeCallback, DelegatedClusterCallback { + public static class DelegatedLongAttributeCallback + implements ChipClusters.LongAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -129,7 +130,8 @@ public void onError(Exception error) { } } - public static class DelegatedBooleanAttributeCallback implements ChipClusters.BooleanAttributeCallback, DelegatedClusterCallback { + public static class DelegatedBooleanAttributeCallback + implements ChipClusters.BooleanAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -151,7 +153,8 @@ public void onError(Exception error) { } } - public static class DelegatedFloatAttributeCallback implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { + public static class DelegatedFloatAttributeCallback + implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -173,7 +176,8 @@ public void onError(Exception error) { } } - public static class DelegatedDoubleAttributeCallback implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { + public static class DelegatedDoubleAttributeCallback + implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -195,7 +199,8 @@ public void onError(Exception error) { } } - public static class DelegatedDefaultClusterCallback implements DefaultClusterCallback, DelegatedClusterCallback { + public static class DelegatedDefaultClusterCallback + implements DefaultClusterCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -203,7 +208,8 @@ public void setCallbackDelegate(ClusterCommandCallback callback) { this.callback = callback; } - // Parameters and list-adds here should be generated - refer to the template code that creates each callback interface. + // Parameters and list-adds here should be generated - refer to the template code that creates + // each callback interface. @Override public void onSuccess() { Map responseValues = new LinkedHashMap<>(); @@ -216,7544 +222,8880 @@ public void onError(Exception e) { } } + public static class DelegatedAccessControlClusterAclAttributeCallback + implements ChipClusters.AccessControlCluster.AclAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; - public static class DelegatedAccessControlClusterAclAttributeCallback implements ChipClusters.AccessControlCluster.AclAttributeCallback, 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 DelegatedAccessControlClusterExtensionAttributeCallback implements ChipClusters.AccessControlCluster.ExtensionAttributeCallback, 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 DelegatedAccessControlClusterAttributeListAttributeCallback implements ChipClusters.AccessControlCluster.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 DelegatedGetSetupPINResponseCallback implements ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(String setupPIN) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("setupPIN", "String"); - responseValues.put(setupPINResponseValue, setupPIN); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedAccountLoginClusterAttributeListAttributeCallback implements ChipClusters.AccountLoginCluster.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 DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback implements ChipClusters.AdministratorCommissioningCluster.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 DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback implements ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback, 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 DelegatedApplicationBasicClusterAttributeListAttributeCallback implements ChipClusters.ApplicationBasicCluster.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 DelegatedLauncherResponseCallback implements ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback implements ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback, 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 DelegatedApplicationLauncherClusterAttributeListAttributeCallback implements ChipClusters.ApplicationLauncherCluster.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 DelegatedAudioOutputClusterAudioOutputListAttributeCallback implements ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback, 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 DelegatedAudioOutputClusterAttributeListAttributeCallback implements ChipClusters.AudioOutputCluster.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 DelegatedBarrierControlClusterAttributeListAttributeCallback implements ChipClusters.BarrierControlCluster.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 DelegatedBasicClusterAttributeListAttributeCallback implements ChipClusters.BasicCluster.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 DelegatedBinaryInputBasicClusterAttributeListAttributeCallback implements ChipClusters.BinaryInputBasicCluster.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 DelegatedBindingClusterAttributeListAttributeCallback implements ChipClusters.BindingCluster.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 DelegatedBooleanStateClusterAttributeListAttributeCallback implements ChipClusters.BooleanStateCluster.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 DelegatedBridgedActionsClusterActionListAttributeCallback implements ChipClusters.BridgedActionsCluster.ActionListAttributeCallback, 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 DelegatedBridgedActionsClusterEndpointListAttributeCallback implements ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback, 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 DelegatedBridgedActionsClusterAttributeListAttributeCallback implements ChipClusters.BridgedActionsCluster.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 DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback implements ChipClusters.BridgedDeviceBasicCluster.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 DelegatedChangeChannelResponseCallback implements ChipClusters.ChannelCluster.ChangeChannelResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType) { - Map responseValues = new LinkedHashMap<>(); - // channelMatch: Struct ChannelInfo - // Conversion from this type to Java is not properly implemented yet - CommandResponseInfo errorTypeResponseValue = new CommandResponseInfo("errorType", "Integer"); - responseValues.put(errorTypeResponseValue, errorType); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedChannelClusterChannelListAttributeCallback implements ChipClusters.ChannelCluster.ChannelListAttributeCallback, 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 DelegatedChannelClusterAttributeListAttributeCallback implements ChipClusters.ChannelCluster.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 DelegatedColorControlClusterAttributeListAttributeCallback implements ChipClusters.ColorControlCluster.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 DelegatedLaunchResponseCallback implements ChipClusters.ContentLauncherCluster.LaunchResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback implements ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback, 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 DelegatedContentLauncherClusterAttributeListAttributeCallback implements ChipClusters.ContentLauncherCluster.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 DelegatedDescriptorClusterDeviceListAttributeCallback implements ChipClusters.DescriptorCluster.DeviceListAttributeCallback, 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 DelegatedDescriptorClusterServerListAttributeCallback implements ChipClusters.DescriptorCluster.ServerListAttributeCallback, 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 DelegatedDescriptorClusterClientListAttributeCallback implements ChipClusters.DescriptorCluster.ClientListAttributeCallback, 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 DelegatedDescriptorClusterPartsListAttributeCallback implements ChipClusters.DescriptorCluster.PartsListAttributeCallback, 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 DelegatedDescriptorClusterAttributeListAttributeCallback implements ChipClusters.DescriptorCluster.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 DelegatedRetrieveLogsResponseCallback implements ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo contentResponseValue = new CommandResponseInfo("content", "byte[]"); - responseValues.put(contentResponseValue, content); - CommandResponseInfo timeStampResponseValue = new CommandResponseInfo("timeStamp", "Long"); - responseValues.put(timeStampResponseValue, timeStamp); - CommandResponseInfo timeSinceBootResponseValue = new CommandResponseInfo("timeSinceBoot", "Long"); - responseValues.put(timeSinceBootResponseValue, timeSinceBoot); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedDiagnosticLogsClusterAttributeListAttributeCallback implements ChipClusters.DiagnosticLogsCluster.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 DelegatedGetCredentialStatusResponseCallback implements ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo credentialExistsResponseValue = new CommandResponseInfo("credentialExists", "Boolean"); - responseValues.put(credentialExistsResponseValue, credentialExists); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo nextCredentialIndexResponseValue = new CommandResponseInfo("nextCredentialIndex", "Integer"); - responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetUserResponseCallback implements ChipClusters.DoorLockCluster.GetUserResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo userNameResponseValue = new CommandResponseInfo("userName", "String"); - responseValues.put(userNameResponseValue, userName); - CommandResponseInfo userUniqueIdResponseValue = new CommandResponseInfo("userUniqueId", "Long"); - responseValues.put(userUniqueIdResponseValue, userUniqueId); - CommandResponseInfo userStatusResponseValue = new CommandResponseInfo("userStatus", "Integer"); - responseValues.put(userStatusResponseValue, userStatus); - CommandResponseInfo userTypeResponseValue = new CommandResponseInfo("userType", "Integer"); - responseValues.put(userTypeResponseValue, userType); - CommandResponseInfo credentialRuleResponseValue = new CommandResponseInfo("credentialRule", "Integer"); - responseValues.put(credentialRuleResponseValue, credentialRule); - // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - CommandResponseInfo creatorFabricIndexResponseValue = new CommandResponseInfo("creatorFabricIndex", "Integer"); - responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); - CommandResponseInfo lastModifiedFabricIndexResponseValue = new CommandResponseInfo("lastModifiedFabricIndex", "Integer"); - responseValues.put(lastModifiedFabricIndexResponseValue, lastModifiedFabricIndex); - CommandResponseInfo nextUserIndexResponseValue = new CommandResponseInfo("nextUserIndex", "Integer"); - responseValues.put(nextUserIndexResponseValue, nextUserIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetWeekDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo weekDayIndexResponseValue = new CommandResponseInfo("weekDayIndex", "Integer"); - responseValues.put(weekDayIndexResponseValue, weekDayIndex); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo daysMaskResponseValue = new CommandResponseInfo("daysMask", "Optional"); - responseValues.put(daysMaskResponseValue, daysMask); - CommandResponseInfo startHourResponseValue = new CommandResponseInfo("startHour", "Optional"); - responseValues.put(startHourResponseValue, startHour); - CommandResponseInfo startMinuteResponseValue = new CommandResponseInfo("startMinute", "Optional"); - responseValues.put(startMinuteResponseValue, startMinute); - CommandResponseInfo endHourResponseValue = new CommandResponseInfo("endHour", "Optional"); - responseValues.put(endHourResponseValue, endHour); - CommandResponseInfo endMinuteResponseValue = new CommandResponseInfo("endMinute", "Optional"); - responseValues.put(endMinuteResponseValue, endMinute); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetYearDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo yearDayIndexResponseValue = new CommandResponseInfo("yearDayIndex", "Integer"); - responseValues.put(yearDayIndexResponseValue, yearDayIndex); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo localStartTimeResponseValue = new CommandResponseInfo("localStartTime", "Optional"); - responseValues.put(localStartTimeResponseValue, localStartTime); - CommandResponseInfo localEndTimeResponseValue = new CommandResponseInfo("localEndTime", "Optional"); - responseValues.put(localEndTimeResponseValue, localEndTime); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSetCredentialResponseCallback implements ChipClusters.DoorLockCluster.SetCredentialResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo nextCredentialIndexResponseValue = new CommandResponseInfo("nextCredentialIndex", "Integer"); - responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedDoorLockClusterAttributeListAttributeCallback implements ChipClusters.DoorLockCluster.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 DelegatedElectricalMeasurementClusterAttributeListAttributeCallback implements ChipClusters.ElectricalMeasurementCluster.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 DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.EthernetNetworkDiagnosticsCluster.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 DelegatedFixedLabelClusterLabelListAttributeCallback implements ChipClusters.FixedLabelCluster.LabelListAttributeCallback, 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 DelegatedFixedLabelClusterAttributeListAttributeCallback implements ChipClusters.FixedLabelCluster.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 DelegatedFlowMeasurementClusterAttributeListAttributeCallback implements ChipClusters.FlowMeasurementCluster.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 DelegatedArmFailSafeResponseCallback implements ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedCommissioningCompleteResponseCallback implements ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSetRegulatoryConfigResponseCallback implements ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback implements ChipClusters.GeneralCommissioningCluster.BasicCommissioningInfoListAttributeCallback, 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 DelegatedGeneralCommissioningClusterAttributeListAttributeCallback implements ChipClusters.GeneralCommissioningCluster.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 DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.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 DelegatedKeySetReadAllIndicesResponseCallback implements ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ArrayList groupKeySetIDs) { - Map responseValues = new LinkedHashMap<>(); - // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedKeySetReadResponseCallback implements ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { - Map responseValues = new LinkedHashMap<>(); - // groupKeySet: Struct GroupKeySet - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback implements ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback, 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 DelegatedGroupKeyManagementClusterGroupTableAttributeCallback implements ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback, 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 DelegatedGroupKeyManagementClusterAttributeListAttributeCallback implements ChipClusters.GroupKeyManagementCluster.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 DelegatedAddGroupResponseCallback implements ChipClusters.GroupsCluster.AddGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetGroupMembershipResponseCallback implements ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer capacity, ArrayList groupList) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); - responseValues.put(capacityResponseValue, capacity); - // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveGroupResponseCallback implements ChipClusters.GroupsCluster.RemoveGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedViewGroupResponseCallback implements ChipClusters.GroupsCluster.ViewGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, String groupName) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo groupNameResponseValue = new CommandResponseInfo("groupName", "String"); - responseValues.put(groupNameResponseValue, groupName); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedGroupsClusterAttributeListAttributeCallback implements ChipClusters.GroupsCluster.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 DelegatedIdentifyQueryResponseCallback implements ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer timeout) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo timeoutResponseValue = new CommandResponseInfo("timeout", "Integer"); - responseValues.put(timeoutResponseValue, timeout); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedIdentifyClusterAttributeListAttributeCallback implements ChipClusters.IdentifyCluster.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 DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback implements ChipClusters.IlluminanceMeasurementCluster.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 DelegatedSendKeyResponseCallback implements ChipClusters.KeypadInputCluster.SendKeyResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedKeypadInputClusterAttributeListAttributeCallback implements ChipClusters.KeypadInputCluster.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 DelegatedLevelControlClusterAttributeListAttributeCallback implements ChipClusters.LevelControlCluster.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 DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback implements ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback, 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 DelegatedLowPowerClusterAttributeListAttributeCallback implements ChipClusters.LowPowerCluster.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 DelegatedMediaInputClusterMediaInputListAttributeCallback implements ChipClusters.MediaInputCluster.MediaInputListAttributeCallback, 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 DelegatedMediaInputClusterAttributeListAttributeCallback implements ChipClusters.MediaInputCluster.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 DelegatedPlaybackResponseCallback implements ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedMediaPlaybackClusterAttributeListAttributeCallback implements ChipClusters.MediaPlaybackCluster.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 DelegatedModeSelectClusterSupportedModesAttributeCallback implements ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback, 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 DelegatedModeSelectClusterAttributeListAttributeCallback implements ChipClusters.ModeSelectCluster.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 DelegatedConnectNetworkResponseCallback implements ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText, Long ErrorValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - CommandResponseInfo ErrorValueResponseValue = new CommandResponseInfo("ErrorValue", "Long"); - responseValues.put(ErrorValueResponseValue, ErrorValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNetworkConfigResponseCallback implements ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedScanNetworksResponseCallback implements ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText, Optional> WiFiScanResults, Optional> ThreadScanResults) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - // WiFiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - // ThreadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedNetworkCommissioningClusterNetworksAttributeCallback implements ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback, 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 DelegatedApplyUpdateResponseCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer action, Long delayedActionTime) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo actionResponseValue = new CommandResponseInfo("action", "Integer"); - responseValues.put(actionResponseValue, action); - CommandResponseInfo delayedActionTimeResponseValue = new CommandResponseInfo("delayedActionTime", "Long"); - responseValues.put(delayedActionTimeResponseValue, delayedActionTime); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedQueryImageResponseCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo delayedActionTimeResponseValue = new CommandResponseInfo("delayedActionTime", "Optional"); - responseValues.put(delayedActionTimeResponseValue, delayedActionTime); - CommandResponseInfo imageURIResponseValue = new CommandResponseInfo("imageURI", "Optional"); - responseValues.put(imageURIResponseValue, imageURI); - CommandResponseInfo softwareVersionResponseValue = new CommandResponseInfo("softwareVersion", "Optional"); - responseValues.put(softwareVersionResponseValue, softwareVersion); - CommandResponseInfo softwareVersionStringResponseValue = new CommandResponseInfo("softwareVersionString", "Optional"); - responseValues.put(softwareVersionStringResponseValue, softwareVersionString); - CommandResponseInfo updateTokenResponseValue = new CommandResponseInfo("updateToken", "Optional"); - responseValues.put(updateTokenResponseValue, updateToken); - CommandResponseInfo userConsentNeededResponseValue = new CommandResponseInfo("userConsentNeeded", "Optional"); - responseValues.put(userConsentNeededResponseValue, userConsentNeeded); - CommandResponseInfo metadataForRequestorResponseValue = new CommandResponseInfo("metadataForRequestor", "Optional"); - responseValues.put(metadataForRequestorResponseValue, metadataForRequestor); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.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 DelegatedOtaSoftwareUpdateRequestorClusterDefaultOtaProvidersAttributeCallback implements ChipClusters.OtaSoftwareUpdateRequestorCluster.DefaultOtaProvidersAttributeCallback, 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 DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback implements ChipClusters.OtaSoftwareUpdateRequestorCluster.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 DelegatedOccupancySensingClusterAttributeListAttributeCallback implements ChipClusters.OccupancySensingCluster.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 DelegatedOnOffClusterAttributeListAttributeCallback implements ChipClusters.OnOffCluster.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 DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback implements ChipClusters.OnOffSwitchConfigurationCluster.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 DelegatedAttestationResponseCallback implements ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] AttestationElements, byte[] Signature) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo AttestationElementsResponseValue = new CommandResponseInfo("AttestationElements", "byte[]"); - responseValues.put(AttestationElementsResponseValue, AttestationElements); - CommandResponseInfo SignatureResponseValue = new CommandResponseInfo("Signature", "byte[]"); - responseValues.put(SignatureResponseValue, Signature); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedCertificateChainResponseCallback implements ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] Certificate) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo CertificateResponseValue = new CommandResponseInfo("Certificate", "byte[]"); - responseValues.put(CertificateResponseValue, Certificate); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNOCResponseCallback implements ChipClusters.OperationalCredentialsCluster.NOCResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer StatusCode, Integer FabricIndex, String DebugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo StatusCodeResponseValue = new CommandResponseInfo("StatusCode", "Integer"); - responseValues.put(StatusCodeResponseValue, StatusCode); - CommandResponseInfo FabricIndexResponseValue = new CommandResponseInfo("FabricIndex", "Integer"); - responseValues.put(FabricIndexResponseValue, FabricIndex); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedOpCSRResponseCallback implements ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] NOCSRElements, byte[] AttestationSignature) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NOCSRElementsResponseValue = new CommandResponseInfo("NOCSRElements", "byte[]"); - responseValues.put(NOCSRElementsResponseValue, NOCSRElements); - CommandResponseInfo AttestationSignatureResponseValue = new CommandResponseInfo("AttestationSignature", "byte[]"); - responseValues.put(AttestationSignatureResponseValue, AttestationSignature); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedOperationalCredentialsClusterNOCsAttributeCallback implements ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback, 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 DelegatedOperationalCredentialsClusterFabricsListAttributeCallback implements ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback, 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 DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback implements ChipClusters.OperationalCredentialsCluster.TrustedRootCertificatesAttributeCallback, 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 DelegatedOperationalCredentialsClusterAttributeListAttributeCallback implements ChipClusters.OperationalCredentialsCluster.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 DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback implements ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback, 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 DelegatedPowerSourceClusterAttributeListAttributeCallback implements ChipClusters.PowerSourceCluster.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 DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback implements ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback, 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 DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback implements ChipClusters.PowerSourceConfigurationCluster.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 DelegatedPressureMeasurementClusterAttributeListAttributeCallback implements ChipClusters.PressureMeasurementCluster.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 DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback implements ChipClusters.PumpConfigurationAndControlCluster.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 DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback implements ChipClusters.RelativeHumidityMeasurementCluster.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 DelegatedAddSceneResponseCallback implements ChipClusters.ScenesCluster.AddSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetSceneMembershipResponseCallback implements ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); - responseValues.put(capacityResponseValue, capacity); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneCountResponseValue = new CommandResponseInfo("sceneCount", "Integer"); - responseValues.put(sceneCountResponseValue, sceneCount); - // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveAllScenesResponseCallback implements ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveSceneResponseCallback implements ChipClusters.ScenesCluster.RemoveSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedStoreSceneResponseCallback implements ChipClusters.ScenesCluster.StoreSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedViewSceneResponseCallback implements ChipClusters.ScenesCluster.ViewSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - CommandResponseInfo transitionTimeResponseValue = new CommandResponseInfo("transitionTime", "Integer"); - responseValues.put(transitionTimeResponseValue, transitionTime); - CommandResponseInfo sceneNameResponseValue = new CommandResponseInfo("sceneName", "String"); - responseValues.put(sceneNameResponseValue, sceneName); - // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedScenesClusterAttributeListAttributeCallback implements ChipClusters.ScenesCluster.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 DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback implements ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback, 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 DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.SoftwareDiagnosticsCluster.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 DelegatedSwitchClusterAttributeListAttributeCallback implements ChipClusters.SwitchCluster.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 DelegatedNavigateTargetResponseCallback implements ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback implements ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback, 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 DelegatedTargetNavigatorClusterAttributeListAttributeCallback implements ChipClusters.TargetNavigatorCluster.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 DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback implements ChipClusters.TemperatureMeasurementCluster.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 DelegatedBooleanResponseCallback implements ChipClusters.TestClusterCluster.BooleanResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Boolean value) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Boolean"); - responseValues.put(valueResponseValue, value); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSimpleStructResponseCallback implements ChipClusters.TestClusterCluster.SimpleStructResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1) { - Map responseValues = new LinkedHashMap<>(); - // arg1: Struct SimpleStruct - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestAddArgumentsResponseCallback implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer returnValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo returnValueResponseValue = new CommandResponseInfo("returnValue", "Integer"); - responseValues.put(returnValueResponseValue, returnValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestEmitTestEventResponseCallback implements ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Long value) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Long"); - responseValues.put(valueResponseValue, value); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestEnumsResponseCallback implements ChipClusters.TestClusterCluster.TestEnumsResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer arg1, Integer arg2) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo arg1ResponseValue = new CommandResponseInfo("arg1", "Integer"); - responseValues.put(arg1ResponseValue, arg1); - CommandResponseInfo arg2ResponseValue = new CommandResponseInfo("arg2", "Integer"); - responseValues.put(arg2ResponseValue, arg2); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestListInt8UReverseResponseCallback implements ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ArrayList arg1) { - Map responseValues = new LinkedHashMap<>(); - // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestNullableOptionalResponseCallback implements ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo wasPresentResponseValue = new CommandResponseInfo("wasPresent", "Boolean"); - responseValues.put(wasPresentResponseValue, wasPresent); - CommandResponseInfo wasNullResponseValue = new CommandResponseInfo("wasNull", "Optional"); - responseValues.put(wasNullResponseValue, wasNull); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Optional"); - responseValues.put(valueResponseValue, value); - CommandResponseInfo originalValueResponseValue = new CommandResponseInfo("originalValue", "Optional"); - responseValues.put(originalValueResponseValue, originalValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestSpecificResponseCallback implements ChipClusters.TestClusterCluster.TestSpecificResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer returnValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo returnValueResponseValue = new CommandResponseInfo("returnValue", "Integer"); - responseValues.put(returnValueResponseValue, returnValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedTestClusterClusterListInt8uAttributeCallback implements ChipClusters.TestClusterCluster.ListInt8uAttributeCallback, 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 DelegatedTestClusterClusterListOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback, 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 DelegatedTestClusterClusterListStructOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback, 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 DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback implements ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback, 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 DelegatedTestClusterClusterListLongOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback, 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 DelegatedTestClusterClusterAttributeListAttributeCallback implements ChipClusters.TestClusterCluster.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 DelegatedGetRelayStatusLogResponseCallback implements ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo timeOfDayResponseValue = new CommandResponseInfo("timeOfDay", "Integer"); - responseValues.put(timeOfDayResponseValue, timeOfDay); - CommandResponseInfo relayStatusResponseValue = new CommandResponseInfo("relayStatus", "Integer"); - responseValues.put(relayStatusResponseValue, relayStatus); - CommandResponseInfo localTemperatureResponseValue = new CommandResponseInfo("localTemperature", "Integer"); - responseValues.put(localTemperatureResponseValue, localTemperature); - CommandResponseInfo humidityInPercentageResponseValue = new CommandResponseInfo("humidityInPercentage", "Integer"); - responseValues.put(humidityInPercentageResponseValue, humidityInPercentage); - CommandResponseInfo setpointResponseValue = new CommandResponseInfo("setpoint", "Integer"); - responseValues.put(setpointResponseValue, setpoint); - CommandResponseInfo unreadEntriesResponseValue = new CommandResponseInfo("unreadEntries", "Integer"); - responseValues.put(unreadEntriesResponseValue, unreadEntries); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetWeeklyScheduleResponseCallback implements ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo numberOfTransitionsForSequenceResponseValue = new CommandResponseInfo("numberOfTransitionsForSequence", "Integer"); - responseValues.put(numberOfTransitionsForSequenceResponseValue, numberOfTransitionsForSequence); - CommandResponseInfo dayOfWeekForSequenceResponseValue = new CommandResponseInfo("dayOfWeekForSequence", "Integer"); - responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); - CommandResponseInfo modeForSequenceResponseValue = new CommandResponseInfo("modeForSequence", "Integer"); - responseValues.put(modeForSequenceResponseValue, modeForSequence); - // payload: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedThermostatClusterAttributeListAttributeCallback implements ChipClusters.ThermostatCluster.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 DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback implements ChipClusters.ThermostatUserInterfaceConfigurationCluster.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 DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.OperationalDatasetComponentsAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.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 DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback implements ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback, 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 DelegatedUserLabelClusterLabelListAttributeCallback implements ChipClusters.UserLabelCluster.LabelListAttributeCallback, 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 DelegatedWakeOnLanClusterAttributeListAttributeCallback implements ChipClusters.WakeOnLanCluster.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 DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.WiFiNetworkDiagnosticsCluster.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 DelegatedWindowCoveringClusterAttributeListAttributeCallback implements ChipClusters.WindowCoveringCluster.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 Map getClusterMap() { - Map clusterMap = initializeClusterMap(); - Map> commandMap = getCommandMap(); - combineCommand(clusterMap, commandMap); - Map> readAttributeMap = new ClusterReadMapping().getReadAttributeMap(); - combineCommand(clusterMap, readAttributeMap); - Map> writeAttributeMap = new ClusterWriteMapping().getWriteAttributeMap(); - combineCommand(clusterMap, writeAttributeMap); - return clusterMap; - } + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } - public Map initializeClusterMap() { - Map clusterMap = new HashMap<>(); - ClusterInfo accessControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AccessControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("accessControl", accessControlClusterInfo); - ClusterInfo accountLoginClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("accountLogin", accountLoginClusterInfo); - ClusterInfo administratorCommissioningClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); - ClusterInfo applicationBasicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("applicationBasic", applicationBasicClusterInfo); - ClusterInfo applicationLauncherClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); - ClusterInfo audioOutputClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("audioOutput", audioOutputClusterInfo); - ClusterInfo barrierControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("barrierControl", barrierControlClusterInfo); - ClusterInfo basicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("basic", basicClusterInfo); - ClusterInfo binaryInputBasicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); - ClusterInfo bindingClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("binding", bindingClusterInfo); - ClusterInfo booleanStateClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("booleanState", booleanStateClusterInfo); - ClusterInfo bridgedActionsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("bridgedActions", bridgedActionsClusterInfo); - ClusterInfo bridgedDeviceBasicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); - ClusterInfo channelClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ChannelCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("channel", channelClusterInfo); - ClusterInfo colorControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("colorControl", colorControlClusterInfo); - ClusterInfo contentLauncherClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("contentLauncher", contentLauncherClusterInfo); - ClusterInfo descriptorClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("descriptor", descriptorClusterInfo); - ClusterInfo diagnosticLogsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); - ClusterInfo doorLockClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("doorLock", doorLockClusterInfo); - ClusterInfo electricalMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); - ClusterInfo ethernetNetworkDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); - ClusterInfo fixedLabelClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("fixedLabel", fixedLabelClusterInfo); - ClusterInfo flowMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); - ClusterInfo generalCommissioningClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); - ClusterInfo generalDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); - ClusterInfo groupKeyManagementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); - ClusterInfo groupsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("groups", groupsClusterInfo); - ClusterInfo identifyClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("identify", identifyClusterInfo); - ClusterInfo illuminanceMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); - ClusterInfo keypadInputClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("keypadInput", keypadInputClusterInfo); - ClusterInfo levelControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("levelControl", levelControlClusterInfo); - ClusterInfo localizationConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LocalizationConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("localizationConfiguration", localizationConfigurationClusterInfo); - ClusterInfo lowPowerClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("lowPower", lowPowerClusterInfo); - ClusterInfo mediaInputClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("mediaInput", mediaInputClusterInfo); - ClusterInfo mediaPlaybackClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); - ClusterInfo modeSelectClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("modeSelect", modeSelectClusterInfo); - ClusterInfo networkCommissioningClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); - ClusterInfo otaSoftwareUpdateProviderClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); - ClusterInfo otaSoftwareUpdateRequestorClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); - ClusterInfo occupancySensingClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("occupancySensing", occupancySensingClusterInfo); - ClusterInfo onOffClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("onOff", onOffClusterInfo); - ClusterInfo onOffSwitchConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); - ClusterInfo operationalCredentialsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); - ClusterInfo powerSourceClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("powerSource", powerSourceClusterInfo); - ClusterInfo powerSourceConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PowerSourceConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInfo); - ClusterInfo pressureMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); - ClusterInfo pumpConfigurationAndControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); - ClusterInfo relativeHumidityMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); - ClusterInfo scenesClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("scenes", scenesClusterInfo); - ClusterInfo softwareDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); - ClusterInfo switchClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("switch", switchClusterInfo); - ClusterInfo targetNavigatorClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("targetNavigator", targetNavigatorClusterInfo); - ClusterInfo temperatureMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); - ClusterInfo testClusterClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("testCluster", testClusterClusterInfo); - ClusterInfo thermostatClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("thermostat", thermostatClusterInfo); - ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); - ClusterInfo threadNetworkDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); - ClusterInfo timeFormatLocalizationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TimeFormatLocalizationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("timeFormatLocalization", timeFormatLocalizationClusterInfo); - ClusterInfo unitLocalizationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.UnitLocalizationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("unitLocalization", unitLocalizationClusterInfo); - ClusterInfo userLabelClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.UserLabelCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("userLabel", userLabelClusterInfo); - ClusterInfo wakeOnLanClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); - ClusterInfo wiFiNetworkDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); - ClusterInfo windowCoveringClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("windowCovering", windowCoveringClusterInfo); - return clusterMap; - } - - public void combineCommand(Map destination, Map> source) { - destination.get("accessControl").combineCommands(source.get("accessControl")); - destination.get("accountLogin").combineCommands(source.get("accountLogin")); - destination.get("administratorCommissioning").combineCommands(source.get("administratorCommissioning")); - destination.get("applicationBasic").combineCommands(source.get("applicationBasic")); - destination.get("applicationLauncher").combineCommands(source.get("applicationLauncher")); - destination.get("audioOutput").combineCommands(source.get("audioOutput")); - destination.get("barrierControl").combineCommands(source.get("barrierControl")); - destination.get("basic").combineCommands(source.get("basic")); - destination.get("binaryInputBasic").combineCommands(source.get("binaryInputBasic")); - destination.get("binding").combineCommands(source.get("binding")); - destination.get("booleanState").combineCommands(source.get("booleanState")); - destination.get("bridgedActions").combineCommands(source.get("bridgedActions")); - destination.get("bridgedDeviceBasic").combineCommands(source.get("bridgedDeviceBasic")); - destination.get("channel").combineCommands(source.get("channel")); - destination.get("colorControl").combineCommands(source.get("colorControl")); - destination.get("contentLauncher").combineCommands(source.get("contentLauncher")); - destination.get("descriptor").combineCommands(source.get("descriptor")); - destination.get("diagnosticLogs").combineCommands(source.get("diagnosticLogs")); - destination.get("doorLock").combineCommands(source.get("doorLock")); - destination.get("electricalMeasurement").combineCommands(source.get("electricalMeasurement")); - destination.get("ethernetNetworkDiagnostics").combineCommands(source.get("ethernetNetworkDiagnostics")); - destination.get("fixedLabel").combineCommands(source.get("fixedLabel")); - destination.get("flowMeasurement").combineCommands(source.get("flowMeasurement")); - destination.get("generalCommissioning").combineCommands(source.get("generalCommissioning")); - destination.get("generalDiagnostics").combineCommands(source.get("generalDiagnostics")); - destination.get("groupKeyManagement").combineCommands(source.get("groupKeyManagement")); - destination.get("groups").combineCommands(source.get("groups")); - destination.get("identify").combineCommands(source.get("identify")); - destination.get("illuminanceMeasurement").combineCommands(source.get("illuminanceMeasurement")); - destination.get("keypadInput").combineCommands(source.get("keypadInput")); - destination.get("levelControl").combineCommands(source.get("levelControl")); - destination.get("localizationConfiguration").combineCommands(source.get("localizationConfiguration")); - destination.get("lowPower").combineCommands(source.get("lowPower")); - destination.get("mediaInput").combineCommands(source.get("mediaInput")); - destination.get("mediaPlayback").combineCommands(source.get("mediaPlayback")); - destination.get("modeSelect").combineCommands(source.get("modeSelect")); - destination.get("networkCommissioning").combineCommands(source.get("networkCommissioning")); - destination.get("otaSoftwareUpdateProvider").combineCommands(source.get("otaSoftwareUpdateProvider")); - destination.get("otaSoftwareUpdateRequestor").combineCommands(source.get("otaSoftwareUpdateRequestor")); - destination.get("occupancySensing").combineCommands(source.get("occupancySensing")); - destination.get("onOff").combineCommands(source.get("onOff")); - destination.get("onOffSwitchConfiguration").combineCommands(source.get("onOffSwitchConfiguration")); - destination.get("operationalCredentials").combineCommands(source.get("operationalCredentials")); - destination.get("powerSource").combineCommands(source.get("powerSource")); - destination.get("powerSourceConfiguration").combineCommands(source.get("powerSourceConfiguration")); - destination.get("pressureMeasurement").combineCommands(source.get("pressureMeasurement")); - destination.get("pumpConfigurationAndControl").combineCommands(source.get("pumpConfigurationAndControl")); - destination.get("relativeHumidityMeasurement").combineCommands(source.get("relativeHumidityMeasurement")); - destination.get("scenes").combineCommands(source.get("scenes")); - destination.get("softwareDiagnostics").combineCommands(source.get("softwareDiagnostics")); - destination.get("switch").combineCommands(source.get("switch")); - destination.get("targetNavigator").combineCommands(source.get("targetNavigator")); - destination.get("temperatureMeasurement").combineCommands(source.get("temperatureMeasurement")); - destination.get("testCluster").combineCommands(source.get("testCluster")); - destination.get("thermostat").combineCommands(source.get("thermostat")); - destination.get("thermostatUserInterfaceConfiguration").combineCommands(source.get("thermostatUserInterfaceConfiguration")); - destination.get("threadNetworkDiagnostics").combineCommands(source.get("threadNetworkDiagnostics")); - destination.get("timeFormatLocalization").combineCommands(source.get("timeFormatLocalization")); - destination.get("unitLocalization").combineCommands(source.get("unitLocalization")); - destination.get("userLabel").combineCommands(source.get("userLabel")); - destination.get("wakeOnLan").combineCommands(source.get("wakeOnLan")); - destination.get("wiFiNetworkDiagnostics").combineCommands(source.get("wiFiNetworkDiagnostics")); - destination.get("windowCovering").combineCommands(source.get("windowCovering")); - } - - @SuppressWarnings("unchecked") - public Map> getCommandMap() { - Map> commandMap = new HashMap<>(); - Map accessControlClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("accessControl", accessControlClusterInteractionInfoMap); - Map accountLoginClusterInteractionInfoMap = new LinkedHashMap<>(); - Map accountLogingetSetupPINRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); - accountLogingetSetupPINRequestCommandParams.put("tempAccountIdentifier",accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); - - InteractionInfo accountLogingetSetupPINRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .getSetupPINRequest((ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback) callback - , (String) - commandArguments.get("tempAccountIdentifier") - , 10000 - ); - }, - () -> new DelegatedGetSetupPINResponseCallback(), - accountLogingetSetupPINRequestCommandParams - ); - accountLoginClusterInteractionInfoMap.put("getSetupPINRequest", accountLogingetSetupPINRequestInteractionInfo); - Map accountLoginloginRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); - accountLoginloginRequestCommandParams.put("tempAccountIdentifier",accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); - - CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = new CommandParameterInfo("setupPIN", String.class); - accountLoginloginRequestCommandParams.put("setupPIN",accountLoginloginRequestsetupPINCommandParameterInfo); - - InteractionInfo accountLoginloginRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .loginRequest((DefaultClusterCallback) callback - , (String) - commandArguments.get("tempAccountIdentifier") - , (String) - commandArguments.get("setupPIN") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - accountLoginloginRequestCommandParams - ); - accountLoginClusterInteractionInfoMap.put("loginRequest", accountLoginloginRequestInteractionInfo); - Map accountLoginlogoutRequestCommandParams = new LinkedHashMap(); - InteractionInfo accountLoginlogoutRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .logoutRequest((DefaultClusterCallback) callback - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - accountLoginlogoutRequestCommandParams - ); - accountLoginClusterInteractionInfoMap.put("logoutRequest", accountLoginlogoutRequestInteractionInfo); - commandMap.put("accountLogin", accountLoginClusterInteractionInfoMap); - Map administratorCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); - Map administratorCommissioningopenBasicCommissioningWindowCommandParams = new LinkedHashMap(); - CommandParameterInfo administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); - administratorCommissioningopenBasicCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); - - InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .openBasicCommissioningWindow((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("commissioningTimeout") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningopenBasicCommissioningWindowCommandParams - ); - administratorCommissioningClusterInteractionInfoMap.put("openBasicCommissioningWindow", administratorCommissioningopenBasicCommissioningWindowInteractionInfo); - Map administratorCommissioningopenCommissioningWindowCommandParams = new LinkedHashMap(); - CommandParameterInfo administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = new CommandParameterInfo("PAKEVerifier", byte[].class); - administratorCommissioningopenCommissioningWindowCommandParams.put("PAKEVerifier",administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = new CommandParameterInfo("discriminator", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("discriminator",administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = new CommandParameterInfo("iterations", Long.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("iterations",administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = new CommandParameterInfo("salt", byte[].class); - administratorCommissioningopenCommissioningWindowCommandParams.put("salt",administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = new CommandParameterInfo("passcodeID", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("passcodeID",administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); - - InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .openCommissioningWindow((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("commissioningTimeout") - , (byte[]) - commandArguments.get("PAKEVerifier") - , (Integer) - commandArguments.get("discriminator") - , (Long) - commandArguments.get("iterations") - , (byte[]) - commandArguments.get("salt") - , (Integer) - commandArguments.get("passcodeID") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningopenCommissioningWindowCommandParams - ); - administratorCommissioningClusterInteractionInfoMap.put("openCommissioningWindow", administratorCommissioningopenCommissioningWindowInteractionInfo); - Map administratorCommissioningrevokeCommissioningCommandParams = new LinkedHashMap(); - InteractionInfo administratorCommissioningrevokeCommissioningInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .revokeCommissioning((DefaultClusterCallback) callback - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningrevokeCommissioningCommandParams - ); - administratorCommissioningClusterInteractionInfoMap.put("revokeCommissioning", administratorCommissioningrevokeCommissioningInteractionInfo); - commandMap.put("administratorCommissioning", administratorCommissioningClusterInteractionInfoMap); - Map applicationBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("applicationBasic", applicationBasicClusterInteractionInfoMap); - Map applicationLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); - Map applicationLauncherhideAppRequestCommandParams = new LinkedHashMap(); - InteractionInfo applicationLauncherhideAppRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .hideAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback - , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application") - - ); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherhideAppRequestCommandParams - ); - applicationLauncherClusterInteractionInfoMap.put("hideAppRequest", applicationLauncherhideAppRequestInteractionInfo); - Map applicationLauncherlaunchAppRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); - applicationLauncherlaunchAppRequestCommandParams.put("data",applicationLauncherlaunchAppRequestdataCommandParameterInfo); - - InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .launchAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback - , (String) - commandArguments.get("data") - , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application") - - ); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherlaunchAppRequestCommandParams - ); - applicationLauncherClusterInteractionInfoMap.put("launchAppRequest", applicationLauncherlaunchAppRequestInteractionInfo); - Map applicationLauncherstopAppRequestCommandParams = new LinkedHashMap(); - InteractionInfo applicationLauncherstopAppRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .stopAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback - , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application") - - ); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherstopAppRequestCommandParams - ); - applicationLauncherClusterInteractionInfoMap.put("stopAppRequest", applicationLauncherstopAppRequestInteractionInfo); - commandMap.put("applicationLauncher", applicationLauncherClusterInteractionInfoMap); - Map audioOutputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map audioOutputrenameOutputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - audioOutputrenameOutputRequestCommandParams.put("index",audioOutputrenameOutputRequestindexCommandParameterInfo); - - CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); - audioOutputrenameOutputRequestCommandParams.put("name",audioOutputrenameOutputRequestnameCommandParameterInfo); - - InteractionInfo audioOutputrenameOutputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .renameOutputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - , (String) - commandArguments.get("name") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - audioOutputrenameOutputRequestCommandParams - ); - audioOutputClusterInteractionInfoMap.put("renameOutputRequest", audioOutputrenameOutputRequestInteractionInfo); - Map audioOutputselectOutputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - audioOutputselectOutputRequestCommandParams.put("index",audioOutputselectOutputRequestindexCommandParameterInfo); - - InteractionInfo audioOutputselectOutputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .selectOutputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - audioOutputselectOutputRequestCommandParams - ); - audioOutputClusterInteractionInfoMap.put("selectOutputRequest", audioOutputselectOutputRequestInteractionInfo); - commandMap.put("audioOutput", audioOutputClusterInteractionInfoMap); - Map barrierControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map barrierControlbarrierControlGoToPercentCommandParams = new LinkedHashMap(); - CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = new CommandParameterInfo("percentOpen", Integer.class); - barrierControlbarrierControlGoToPercentCommandParams.put("percentOpen",barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); - - InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .barrierControlGoToPercent((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("percentOpen") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - barrierControlbarrierControlGoToPercentCommandParams - ); - barrierControlClusterInteractionInfoMap.put("barrierControlGoToPercent", barrierControlbarrierControlGoToPercentInteractionInfo); - Map barrierControlbarrierControlStopCommandParams = new LinkedHashMap(); - InteractionInfo barrierControlbarrierControlStopInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .barrierControlStop((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - barrierControlbarrierControlStopCommandParams - ); - barrierControlClusterInteractionInfoMap.put("barrierControlStop", barrierControlbarrierControlStopInteractionInfo); - commandMap.put("barrierControl", barrierControlClusterInteractionInfoMap); - Map basicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("basic", basicClusterInteractionInfoMap); - Map binaryInputBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("binaryInputBasic", binaryInputBasicClusterInteractionInfoMap); - Map bindingClusterInteractionInfoMap = new LinkedHashMap<>(); - Map bindingbindCommandParams = new LinkedHashMap(); - CommandParameterInfo bindingbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); - bindingbindCommandParams.put("nodeId",bindingbindnodeIdCommandParameterInfo); - - CommandParameterInfo bindingbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - bindingbindCommandParams.put("groupId",bindingbindgroupIdCommandParameterInfo); - - CommandParameterInfo bindingbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); - bindingbindCommandParams.put("endpointId",bindingbindendpointIdCommandParameterInfo); - - CommandParameterInfo bindingbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); - bindingbindCommandParams.put("clusterId",bindingbindclusterIdCommandParameterInfo); - - InteractionInfo bindingbindInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .bind((DefaultClusterCallback) callback - , (Long) - commandArguments.get("nodeId") - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("endpointId") - , (Long) - commandArguments.get("clusterId") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bindingbindCommandParams - ); - bindingClusterInteractionInfoMap.put("bind", bindingbindInteractionInfo); - Map bindingunbindCommandParams = new LinkedHashMap(); - CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); - bindingunbindCommandParams.put("nodeId",bindingunbindnodeIdCommandParameterInfo); - - CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - bindingunbindCommandParams.put("groupId",bindingunbindgroupIdCommandParameterInfo); - - CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); - bindingunbindCommandParams.put("endpointId",bindingunbindendpointIdCommandParameterInfo); - - CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); - bindingunbindCommandParams.put("clusterId",bindingunbindclusterIdCommandParameterInfo); - - InteractionInfo bindingunbindInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .unbind((DefaultClusterCallback) callback - , (Long) - commandArguments.get("nodeId") - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("endpointId") - , (Long) - commandArguments.get("clusterId") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bindingunbindCommandParams - ); - bindingClusterInteractionInfoMap.put("unbind", bindingunbindInteractionInfo); - commandMap.put("binding", bindingClusterInteractionInfoMap); - Map booleanStateClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("booleanState", booleanStateClusterInteractionInfoMap); - Map bridgedActionsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map bridgedActionsdisableActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsdisableActionCommandParams.put("actionID",bridgedActionsdisableActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsdisableActionCommandParams.put("invokeID",bridgedActionsdisableActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsdisableActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .disableAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsdisableActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("disableAction", bridgedActionsdisableActionInteractionInfo); - Map bridgedActionsdisableActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsdisableActionWithDurationCommandParams.put("actionID",bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsdisableActionWithDurationCommandParams.put("invokeID",bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionsdisableActionWithDurationCommandParams.put("duration",bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .disableActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsdisableActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("disableActionWithDuration", bridgedActionsdisableActionWithDurationInteractionInfo); - Map bridgedActionsenableActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsenableActionCommandParams.put("actionID",bridgedActionsenableActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsenableActionCommandParams.put("invokeID",bridgedActionsenableActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsenableActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .enableAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsenableActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("enableAction", bridgedActionsenableActionInteractionInfo); - Map bridgedActionsenableActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsenableActionWithDurationCommandParams.put("actionID",bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsenableActionWithDurationCommandParams.put("invokeID",bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionsenableActionWithDurationCommandParams.put("duration",bridgedActionsenableActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .enableActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsenableActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("enableActionWithDuration", bridgedActionsenableActionWithDurationInteractionInfo); - Map bridgedActionsinstantActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsinstantActionCommandParams.put("actionID",bridgedActionsinstantActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsinstantActionCommandParams.put("invokeID",bridgedActionsinstantActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsinstantActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .instantAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsinstantActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("instantAction", bridgedActionsinstantActionInteractionInfo); - Map bridgedActionsinstantActionWithTransitionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsinstantActionWithTransitionCommandParams.put("actionID",bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsinstantActionWithTransitionCommandParams.put("invokeID",bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - bridgedActionsinstantActionWithTransitionCommandParams.put("transitionTime",bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); - - InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .instantActionWithTransition((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsinstantActionWithTransitionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("instantActionWithTransition", bridgedActionsinstantActionWithTransitionInteractionInfo); - Map bridgedActionspauseActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionspauseActionCommandParams.put("actionID",bridgedActionspauseActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionspauseActionCommandParams.put("invokeID",bridgedActionspauseActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionspauseActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .pauseAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionspauseActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("pauseAction", bridgedActionspauseActionInteractionInfo); - Map bridgedActionspauseActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionspauseActionWithDurationCommandParams.put("actionID",bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionspauseActionWithDurationCommandParams.put("invokeID",bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionspauseActionWithDurationCommandParams.put("duration",bridgedActionspauseActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .pauseActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionspauseActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("pauseActionWithDuration", bridgedActionspauseActionWithDurationInteractionInfo); - Map bridgedActionsresumeActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsresumeActionCommandParams.put("actionID",bridgedActionsresumeActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsresumeActionCommandParams.put("invokeID",bridgedActionsresumeActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsresumeActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .resumeAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsresumeActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("resumeAction", bridgedActionsresumeActionInteractionInfo); - Map bridgedActionsstartActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstartActionCommandParams.put("actionID",bridgedActionsstartActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstartActionCommandParams.put("invokeID",bridgedActionsstartActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsstartActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .startAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstartActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("startAction", bridgedActionsstartActionInteractionInfo); - Map bridgedActionsstartActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstartActionWithDurationCommandParams.put("actionID",bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstartActionWithDurationCommandParams.put("invokeID",bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionsstartActionWithDurationCommandParams.put("duration",bridgedActionsstartActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .startActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstartActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("startActionWithDuration", bridgedActionsstartActionWithDurationInteractionInfo); - Map bridgedActionsstopActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstopActionCommandParams.put("actionID",bridgedActionsstopActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstopActionCommandParams.put("invokeID",bridgedActionsstopActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsstopActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .stopAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstopActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("stopAction", bridgedActionsstopActionInteractionInfo); - commandMap.put("bridgedActions", bridgedActionsClusterInteractionInfoMap); - Map bridgedDeviceBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInteractionInfoMap); - Map channelClusterInteractionInfoMap = new LinkedHashMap<>(); - Map channelchangeChannelByNumberRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = new CommandParameterInfo("majorNumber", Integer.class); - channelchangeChannelByNumberRequestCommandParams.put("majorNumber",channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); - - CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = new CommandParameterInfo("minorNumber", Integer.class); - channelchangeChannelByNumberRequestCommandParams.put("minorNumber",channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); - - InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .changeChannelByNumberRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("majorNumber") - , (Integer) - commandArguments.get("minorNumber") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - channelchangeChannelByNumberRequestCommandParams - ); - channelClusterInteractionInfoMap.put("changeChannelByNumberRequest", channelchangeChannelByNumberRequestInteractionInfo); - Map channelchangeChannelRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = new CommandParameterInfo("match", String.class); - channelchangeChannelRequestCommandParams.put("match",channelchangeChannelRequestmatchCommandParameterInfo); - - InteractionInfo channelchangeChannelRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .changeChannelRequest((ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback - , (String) - commandArguments.get("match") - - ); - }, - () -> new DelegatedChangeChannelResponseCallback(), - channelchangeChannelRequestCommandParams - ); - channelClusterInteractionInfoMap.put("changeChannelRequest", channelchangeChannelRequestInteractionInfo); - Map channelskipChannelRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = new CommandParameterInfo("count", Integer.class); - channelskipChannelRequestCommandParams.put("count",channelskipChannelRequestcountCommandParameterInfo); - - InteractionInfo channelskipChannelRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .skipChannelRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("count") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - channelskipChannelRequestCommandParams - ); - channelClusterInteractionInfoMap.put("skipChannelRequest", channelskipChannelRequestInteractionInfo); - commandMap.put("channel", channelClusterInteractionInfoMap); - Map colorControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map colorControlcolorLoopSetCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = new CommandParameterInfo("updateFlags", Integer.class); - colorControlcolorLoopSetCommandParams.put("updateFlags",colorControlcolorLoopSetupdateFlagsCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = new CommandParameterInfo("action", Integer.class); - colorControlcolorLoopSetCommandParams.put("action",colorControlcolorLoopSetactionCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); - colorControlcolorLoopSetCommandParams.put("direction",colorControlcolorLoopSetdirectionCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = new CommandParameterInfo("time", Integer.class); - colorControlcolorLoopSetCommandParams.put("time",colorControlcolorLoopSettimeCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = new CommandParameterInfo("startHue", Integer.class); - colorControlcolorLoopSetCommandParams.put("startHue",colorControlcolorLoopSetstartHueCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlcolorLoopSetCommandParams.put("optionsMask",colorControlcolorLoopSetoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlcolorLoopSetCommandParams.put("optionsOverride",colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlcolorLoopSetInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .colorLoopSet((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("updateFlags") - , (Integer) - commandArguments.get("action") - , (Integer) - commandArguments.get("direction") - , (Integer) - commandArguments.get("time") - , (Integer) - commandArguments.get("startHue") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlcolorLoopSetCommandParams - ); - colorControlClusterInteractionInfoMap.put("colorLoopSet", colorControlcolorLoopSetInteractionInfo); - Map colorControlenhancedMoveHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlenhancedMoveHueCommandParams.put("moveMode",colorControlenhancedMoveHuemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlenhancedMoveHueCommandParams.put("rate",colorControlenhancedMoveHuerateCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveHueCommandParams.put("optionsMask",colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveHueCommandParams.put("optionsOverride",colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedMoveHue", colorControlenhancedMoveHueInteractionInfo); - Map colorControlenhancedMoveToHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("enhancedHue",colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("direction",colorControlenhancedMoveToHuedirectionCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("transitionTime",colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("optionsMask",colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("optionsOverride",colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveToHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveToHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("enhancedHue") - , (Integer) - commandArguments.get("direction") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveToHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedMoveToHue", colorControlenhancedMoveToHueInteractionInfo); - Map colorControlenhancedMoveToHueAndSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("enhancedHue",colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("saturation",colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("transitionTime",colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsMask",colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveToHueAndSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("enhancedHue") - , (Integer) - commandArguments.get("saturation") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveToHueAndSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedMoveToHueAndSaturation", colorControlenhancedMoveToHueAndSaturationInteractionInfo); - Map colorControlenhancedStepHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlenhancedStepHueCommandParams.put("stepMode",colorControlenhancedStepHuestepModeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlenhancedStepHueCommandParams.put("stepSize",colorControlenhancedStepHuestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedStepHueCommandParams.put("transitionTime",colorControlenhancedStepHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedStepHueCommandParams.put("optionsMask",colorControlenhancedStepHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedStepHueCommandParams.put("optionsOverride",colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedStepHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedStepHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedStepHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedStepHue", colorControlenhancedStepHueInteractionInfo); - Map colorControlmoveColorCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = new CommandParameterInfo("rateX", Integer.class); - colorControlmoveColorCommandParams.put("rateX",colorControlmoveColorrateXCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = new CommandParameterInfo("rateY", Integer.class); - colorControlmoveColorCommandParams.put("rateY",colorControlmoveColorrateYCommandParameterInfo); - - CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveColorCommandParams.put("optionsMask",colorControlmoveColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveColorCommandParams.put("optionsOverride",colorControlmoveColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveColorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveColor((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("rateX") - , (Integer) - commandArguments.get("rateY") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveColorCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveColor", colorControlmoveColorInteractionInfo); - Map colorControlmoveColorTemperatureCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("moveMode",colorControlmoveColorTemperaturemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("rate",colorControlmoveColorTemperaturerateCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("optionsMask",colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("optionsOverride",colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveColorTemperatureInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveColorTemperature((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("colorTemperatureMinimum") - , (Integer) - commandArguments.get("colorTemperatureMaximum") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveColorTemperatureCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveColorTemperature", colorControlmoveColorTemperatureInteractionInfo); - Map colorControlmoveHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveHueCommandParams.put("moveMode",colorControlmoveHuemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlmoveHueCommandParams.put("rate",colorControlmoveHuerateCommandParameterInfo); - - CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveHueCommandParams.put("optionsMask",colorControlmoveHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveHueCommandParams.put("optionsOverride",colorControlmoveHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveHue", colorControlmoveHueInteractionInfo); - Map colorControlmoveSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveSaturationCommandParams.put("moveMode",colorControlmoveSaturationmoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlmoveSaturationCommandParams.put("rate",colorControlmoveSaturationrateCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveSaturationCommandParams.put("optionsMask",colorControlmoveSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveSaturationCommandParams.put("optionsOverride",colorControlmoveSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveSaturation", colorControlmoveSaturationInteractionInfo); - Map colorControlmoveToColorCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = new CommandParameterInfo("colorX", Integer.class); - colorControlmoveToColorCommandParams.put("colorX",colorControlmoveToColorcolorXCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = new CommandParameterInfo("colorY", Integer.class); - colorControlmoveToColorCommandParams.put("colorY",colorControlmoveToColorcolorYCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToColorCommandParams.put("transitionTime",colorControlmoveToColortransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToColorCommandParams.put("optionsMask",colorControlmoveToColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToColorCommandParams.put("optionsOverride",colorControlmoveToColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToColorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToColor((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("colorX") - , (Integer) - commandArguments.get("colorY") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToColorCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToColor", colorControlmoveToColorInteractionInfo); - Map colorControlmoveToColorTemperatureCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = new CommandParameterInfo("colorTemperature", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("colorTemperature",colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("transitionTime",colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("optionsMask",colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("optionsOverride",colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToColorTemperature((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("colorTemperature") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToColorTemperatureCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToColorTemperature", colorControlmoveToColorTemperatureInteractionInfo); - Map colorControlmoveToHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); - colorControlmoveToHueCommandParams.put("hue",colorControlmoveToHuehueCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); - colorControlmoveToHueCommandParams.put("direction",colorControlmoveToHuedirectionCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToHueCommandParams.put("transitionTime",colorControlmoveToHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToHueCommandParams.put("optionsMask",colorControlmoveToHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToHueCommandParams.put("optionsOverride",colorControlmoveToHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("hue") - , (Integer) - commandArguments.get("direction") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToHue", colorControlmoveToHueInteractionInfo); - Map colorControlmoveToHueAndSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("hue",colorControlmoveToHueAndSaturationhueCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("saturation",colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("transitionTime",colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("optionsMask",colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToHueAndSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("hue") - , (Integer) - commandArguments.get("saturation") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToHueAndSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToHueAndSaturation", colorControlmoveToHueAndSaturationInteractionInfo); - Map colorControlmoveToSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); - colorControlmoveToSaturationCommandParams.put("saturation",colorControlmoveToSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToSaturationCommandParams.put("transitionTime",colorControlmoveToSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToSaturationCommandParams.put("optionsMask",colorControlmoveToSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToSaturationCommandParams.put("optionsOverride",colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("saturation") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToSaturation", colorControlmoveToSaturationInteractionInfo); - Map colorControlstepColorCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = new CommandParameterInfo("stepX", Integer.class); - colorControlstepColorCommandParams.put("stepX",colorControlstepColorstepXCommandParameterInfo); - - CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = new CommandParameterInfo("stepY", Integer.class); - colorControlstepColorCommandParams.put("stepY",colorControlstepColorstepYCommandParameterInfo); - - CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepColorCommandParams.put("transitionTime",colorControlstepColortransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepColorCommandParams.put("optionsMask",colorControlstepColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepColorCommandParams.put("optionsOverride",colorControlstepColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepColorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepColor((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepX") - , (Integer) - commandArguments.get("stepY") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepColorCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepColor", colorControlstepColorInteractionInfo); - Map colorControlstepColorTemperatureCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlstepColorTemperatureCommandParams.put("stepMode",colorControlstepColorTemperaturestepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlstepColorTemperatureCommandParams.put("stepSize",colorControlstepColorTemperaturestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepColorTemperatureCommandParams.put("transitionTime",colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); - colorControlstepColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); - colorControlstepColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepColorTemperatureCommandParams.put("optionsMask",colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepColorTemperatureCommandParams.put("optionsOverride",colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepColorTemperatureInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepColorTemperature((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("colorTemperatureMinimum") - , (Integer) - commandArguments.get("colorTemperatureMaximum") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepColorTemperatureCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepColorTemperature", colorControlstepColorTemperatureInteractionInfo); - Map colorControlstepHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlstepHueCommandParams.put("stepMode",colorControlstepHuestepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlstepHueCommandParams.put("stepSize",colorControlstepHuestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepHueCommandParams.put("transitionTime",colorControlstepHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepHueCommandParams.put("optionsMask",colorControlstepHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepHueCommandParams.put("optionsOverride",colorControlstepHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepHue", colorControlstepHueInteractionInfo); - Map colorControlstepSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlstepSaturationCommandParams.put("stepMode",colorControlstepSaturationstepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlstepSaturationCommandParams.put("stepSize",colorControlstepSaturationstepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepSaturationCommandParams.put("transitionTime",colorControlstepSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepSaturationCommandParams.put("optionsMask",colorControlstepSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepSaturationCommandParams.put("optionsOverride",colorControlstepSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepSaturation", colorControlstepSaturationInteractionInfo); - Map colorControlstopMoveStepCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstopMoveStepCommandParams.put("optionsMask",colorControlstopMoveStepoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstopMoveStepCommandParams.put("optionsOverride",colorControlstopMoveStepoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstopMoveStepInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stopMoveStep((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstopMoveStepCommandParams - ); - colorControlClusterInteractionInfoMap.put("stopMoveStep", colorControlstopMoveStepInteractionInfo); - commandMap.put("colorControl", colorControlClusterInteractionInfoMap); - Map contentLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); - Map contentLauncherlaunchContentRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = new CommandParameterInfo("autoPlay", Boolean.class); - contentLauncherlaunchContentRequestCommandParams.put("autoPlay",contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); - - CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); - contentLauncherlaunchContentRequestCommandParams.put("data",contentLauncherlaunchContentRequestdataCommandParameterInfo); - - InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .launchContentRequest((ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback - , (Boolean) - commandArguments.get("autoPlay") - , (String) - commandArguments.get("data") - , (ArrayList) - commandArguments.get("search") - - ); - }, - () -> new DelegatedLaunchResponseCallback(), - contentLauncherlaunchContentRequestCommandParams - ); - contentLauncherClusterInteractionInfoMap.put("launchContentRequest", contentLauncherlaunchContentRequestInteractionInfo); - Map contentLauncherlaunchURLRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = new CommandParameterInfo("contentURL", String.class); - contentLauncherlaunchURLRequestCommandParams.put("contentURL",contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); - - CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = new CommandParameterInfo("displayString", String.class); - contentLauncherlaunchURLRequestCommandParams.put("displayString",contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); - - InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .launchURLRequest((ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback - , (String) - commandArguments.get("contentURL") - , (String) - commandArguments.get("displayString") - , (ChipStructs.ContentLauncherClusterBrandingInformation) - commandArguments.get("brandingInformation") - - ); - }, - () -> new DelegatedLaunchResponseCallback(), - contentLauncherlaunchURLRequestCommandParams - ); - contentLauncherClusterInteractionInfoMap.put("launchURLRequest", contentLauncherlaunchURLRequestInteractionInfo); - commandMap.put("contentLauncher", contentLauncherClusterInteractionInfoMap); - Map descriptorClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("descriptor", descriptorClusterInteractionInfoMap); - Map diagnosticLogsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map diagnosticLogsretrieveLogsRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = new CommandParameterInfo("intent", Integer.class); - diagnosticLogsretrieveLogsRequestCommandParams.put("intent",diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); - - CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = new CommandParameterInfo("requestedProtocol", Integer.class); - diagnosticLogsretrieveLogsRequestCommandParams.put("requestedProtocol",diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); - - CommandParameterInfo diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = new CommandParameterInfo("transferFileDesignator", byte[].class); - diagnosticLogsretrieveLogsRequestCommandParams.put("transferFileDesignator",diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); - - InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .retrieveLogsRequest((ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback) callback - , (Integer) - commandArguments.get("intent") - , (Integer) - commandArguments.get("requestedProtocol") - , (byte[]) - commandArguments.get("transferFileDesignator") - - ); - }, - () -> new DelegatedRetrieveLogsResponseCallback(), - diagnosticLogsretrieveLogsRequestCommandParams - ); - diagnosticLogsClusterInteractionInfoMap.put("retrieveLogsRequest", diagnosticLogsretrieveLogsRequestInteractionInfo); - commandMap.put("diagnosticLogs", diagnosticLogsClusterInteractionInfoMap); - Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); - Map doorLockclearCredentialCommandParams = new LinkedHashMap(); - InteractionInfo doorLockclearCredentialInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearCredential((DefaultClusterCallback) callback - , (ChipStructs.DoorLockClusterDlCredential) - commandArguments.get("credential") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearCredentialCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearCredential", doorLockclearCredentialInteractionInfo); - Map doorLockclearUserCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockclearUserCommandParams.put("userIndex",doorLockclearUseruserIndexCommandParameterInfo); - - InteractionInfo doorLockclearUserInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearUser((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("userIndex") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearUserCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearUser", doorLockclearUserInteractionInfo); - Map doorLockclearWeekDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); - doorLockclearWeekDayScheduleCommandParams.put("weekDayIndex",doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockclearWeekDayScheduleCommandParams.put("userIndex",doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearWeekDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("weekDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearWeekDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearWeekDaySchedule", doorLockclearWeekDayScheduleInteractionInfo); - Map doorLockclearYearDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); - doorLockclearYearDayScheduleCommandParams.put("yearDayIndex",doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockclearYearDayScheduleCommandParams.put("userIndex",doorLockclearYearDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockclearYearDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearYearDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("yearDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearYearDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearYearDaySchedule", doorLockclearYearDayScheduleInteractionInfo); - Map doorLockgetCredentialStatusCommandParams = new LinkedHashMap(); - InteractionInfo doorLockgetCredentialStatusInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getCredentialStatus((ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback - , (ChipStructs.DoorLockClusterDlCredential) - commandArguments.get("credential") - - ); - }, - () -> new DelegatedGetCredentialStatusResponseCallback(), - doorLockgetCredentialStatusCommandParams - ); - doorLockClusterInteractionInfoMap.put("getCredentialStatus", doorLockgetCredentialStatusInteractionInfo); - Map doorLockgetUserCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockgetUserCommandParams.put("userIndex",doorLockgetUseruserIndexCommandParameterInfo); - - InteractionInfo doorLockgetUserInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getUser((ChipClusters.DoorLockCluster.GetUserResponseCallback) callback - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedGetUserResponseCallback(), - doorLockgetUserCommandParams - ); - doorLockClusterInteractionInfoMap.put("getUser", doorLockgetUserInteractionInfo); - Map doorLockgetWeekDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); - doorLockgetWeekDayScheduleCommandParams.put("weekDayIndex",doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockgetWeekDayScheduleCommandParams.put("userIndex",doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getWeekDaySchedule((ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback) callback - , (Integer) - commandArguments.get("weekDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedGetWeekDayScheduleResponseCallback(), - doorLockgetWeekDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("getWeekDaySchedule", doorLockgetWeekDayScheduleInteractionInfo); - Map doorLockgetYearDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); - doorLockgetYearDayScheduleCommandParams.put("yearDayIndex",doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockgetYearDayScheduleCommandParams.put("userIndex",doorLockgetYearDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockgetYearDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getYearDaySchedule((ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback) callback - , (Integer) - commandArguments.get("yearDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedGetYearDayScheduleResponseCallback(), - doorLockgetYearDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("getYearDaySchedule", doorLockgetYearDayScheduleInteractionInfo); - Map doorLocklockDoorCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); - doorLocklockDoorCommandParams.put("pinCode",doorLocklockDoorpinCodeCommandParameterInfo); - - InteractionInfo doorLocklockDoorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .lockDoor((DefaultClusterCallback) callback - , (Optional) - commandArguments.get("pinCode") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocklockDoorCommandParams - ); - doorLockClusterInteractionInfoMap.put("lockDoor", doorLocklockDoorInteractionInfo); - Map doorLocksetCredentialCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); - doorLocksetCredentialCommandParams.put("operationType",doorLocksetCredentialoperationTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = new CommandParameterInfo("credentialData", byte[].class); - doorLocksetCredentialCommandParams.put("credentialData",doorLocksetCredentialcredentialDataCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetCredentialCommandParams.put("userIndex",doorLocksetCredentialuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); - doorLocksetCredentialCommandParams.put("userStatus",doorLocksetCredentialuserStatusCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); - doorLocksetCredentialCommandParams.put("userType",doorLocksetCredentialuserTypeCommandParameterInfo); - - InteractionInfo doorLocksetCredentialInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setCredential((ChipClusters.DoorLockCluster.SetCredentialResponseCallback) callback - , (Integer) - commandArguments.get("operationType") - , (ChipStructs.DoorLockClusterDlCredential) - commandArguments.get("credential") - , (byte[]) - commandArguments.get("credentialData") - , (Integer) - commandArguments.get("userIndex") - , (Integer) - commandArguments.get("userStatus") - , (Integer) - commandArguments.get("userType") - , 10000 - ); - }, - () -> new DelegatedSetCredentialResponseCallback(), - doorLocksetCredentialCommandParams - ); - doorLockClusterInteractionInfoMap.put("setCredential", doorLocksetCredentialInteractionInfo); - Map doorLocksetUserCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); - doorLocksetUserCommandParams.put("operationType",doorLocksetUseroperationTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetUserCommandParams.put("userIndex",doorLocksetUseruserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = new CommandParameterInfo("userName", String.class); - doorLocksetUserCommandParams.put("userName",doorLocksetUseruserNameCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = new CommandParameterInfo("userUniqueId", Long.class); - doorLocksetUserCommandParams.put("userUniqueId",doorLocksetUseruserUniqueIdCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); - doorLocksetUserCommandParams.put("userStatus",doorLocksetUseruserStatusCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); - doorLocksetUserCommandParams.put("userType",doorLocksetUseruserTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = new CommandParameterInfo("credentialRule", Integer.class); - doorLocksetUserCommandParams.put("credentialRule",doorLocksetUsercredentialRuleCommandParameterInfo); - - InteractionInfo doorLocksetUserInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setUser((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("operationType") - , (Integer) - commandArguments.get("userIndex") - , (String) - commandArguments.get("userName") - , (Long) - commandArguments.get("userUniqueId") - , (Integer) - commandArguments.get("userStatus") - , (Integer) - commandArguments.get("userType") - , (Integer) - commandArguments.get("credentialRule") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetUserCommandParams - ); - doorLockClusterInteractionInfoMap.put("setUser", doorLocksetUserInteractionInfo); - Map doorLocksetWeekDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("weekDayIndex",doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("userIndex",doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = new CommandParameterInfo("daysMask", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("daysMask",doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = new CommandParameterInfo("startHour", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("startHour",doorLocksetWeekDaySchedulestartHourCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = new CommandParameterInfo("startMinute", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("startMinute",doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = new CommandParameterInfo("endHour", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("endHour",doorLocksetWeekDayScheduleendHourCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = new CommandParameterInfo("endMinute", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("endMinute",doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); - - InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setWeekDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("weekDayIndex") - , (Integer) - commandArguments.get("userIndex") - , (Integer) - commandArguments.get("daysMask") - , (Integer) - commandArguments.get("startHour") - , (Integer) - commandArguments.get("startMinute") - , (Integer) - commandArguments.get("endHour") - , (Integer) - commandArguments.get("endMinute") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetWeekDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("setWeekDaySchedule", doorLocksetWeekDayScheduleInteractionInfo); - Map doorLocksetYearDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); - doorLocksetYearDayScheduleCommandParams.put("yearDayIndex",doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetYearDayScheduleCommandParams.put("userIndex",doorLocksetYearDayScheduleuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = new CommandParameterInfo("localStartTime", Long.class); - doorLocksetYearDayScheduleCommandParams.put("localStartTime",doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = new CommandParameterInfo("localEndTime", Long.class); - doorLocksetYearDayScheduleCommandParams.put("localEndTime",doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); - - InteractionInfo doorLocksetYearDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setYearDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("yearDayIndex") - , (Integer) - commandArguments.get("userIndex") - , (Long) - commandArguments.get("localStartTime") - , (Long) - commandArguments.get("localEndTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetYearDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("setYearDaySchedule", doorLocksetYearDayScheduleInteractionInfo); - Map doorLockunlockDoorCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); - doorLockunlockDoorCommandParams.put("pinCode",doorLockunlockDoorpinCodeCommandParameterInfo); - - InteractionInfo doorLockunlockDoorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .unlockDoor((DefaultClusterCallback) callback - , (Optional) - commandArguments.get("pinCode") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockunlockDoorCommandParams - ); - doorLockClusterInteractionInfoMap.put("unlockDoor", doorLockunlockDoorInteractionInfo); - Map doorLockunlockWithTimeoutCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = new CommandParameterInfo("timeout", Integer.class); - doorLockunlockWithTimeoutCommandParams.put("timeout",doorLockunlockWithTimeouttimeoutCommandParameterInfo); - - CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); - doorLockunlockWithTimeoutCommandParams.put("pinCode",doorLockunlockWithTimeoutpinCodeCommandParameterInfo); - - InteractionInfo doorLockunlockWithTimeoutInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .unlockWithTimeout((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("timeout") - , (Optional) - commandArguments.get("pinCode") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockunlockWithTimeoutCommandParams - ); - doorLockClusterInteractionInfoMap.put("unlockWithTimeout", doorLockunlockWithTimeoutInteractionInfo); - commandMap.put("doorLock", doorLockClusterInteractionInfoMap); - Map electricalMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("electricalMeasurement", electricalMeasurementClusterInteractionInfoMap); - Map ethernetNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map ethernetNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); - InteractionInfo ethernetNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - ethernetNetworkDiagnosticsresetCountsCommandParams - ); - ethernetNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", ethernetNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); - Map fixedLabelClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("fixedLabel", fixedLabelClusterInteractionInfoMap); - Map flowMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("flowMeasurement", flowMeasurementClusterInteractionInfoMap); - Map generalCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); - Map generalCommissioningarmFailSafeCommandParams = new LinkedHashMap(); - CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = new CommandParameterInfo("expiryLengthSeconds", Integer.class); - generalCommissioningarmFailSafeCommandParams.put("expiryLengthSeconds",generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); - - CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - generalCommissioningarmFailSafeCommandParams.put("breadcrumb",generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); - - CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); - generalCommissioningarmFailSafeCommandParams.put("timeoutMs",generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); - - InteractionInfo generalCommissioningarmFailSafeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .armFailSafe((ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback) callback - , (Integer) - commandArguments.get("expiryLengthSeconds") - , (Long) - commandArguments.get("breadcrumb") - , (Long) - commandArguments.get("timeoutMs") - - ); - }, - () -> new DelegatedArmFailSafeResponseCallback(), - generalCommissioningarmFailSafeCommandParams - ); - generalCommissioningClusterInteractionInfoMap.put("armFailSafe", generalCommissioningarmFailSafeInteractionInfo); - Map generalCommissioningcommissioningCompleteCommandParams = new LinkedHashMap(); - InteractionInfo generalCommissioningcommissioningCompleteInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .commissioningComplete((ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback) callback - - ); - }, - () -> new DelegatedCommissioningCompleteResponseCallback(), - generalCommissioningcommissioningCompleteCommandParams - ); - generalCommissioningClusterInteractionInfoMap.put("commissioningComplete", generalCommissioningcommissioningCompleteInteractionInfo); - Map generalCommissioningsetRegulatoryConfigCommandParams = new LinkedHashMap(); - CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = new CommandParameterInfo("location", Integer.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("location",generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = new CommandParameterInfo("countryCode", String.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("countryCode",generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("breadcrumb",generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("timeoutMs",generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); - - InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .setRegulatoryConfig((ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback) callback - , (Integer) - commandArguments.get("location") - , (String) - commandArguments.get("countryCode") - , (Long) - commandArguments.get("breadcrumb") - , (Long) - commandArguments.get("timeoutMs") - - ); - }, - () -> new DelegatedSetRegulatoryConfigResponseCallback(), - generalCommissioningsetRegulatoryConfigCommandParams - ); - generalCommissioningClusterInteractionInfoMap.put("setRegulatoryConfig", generalCommissioningsetRegulatoryConfigInteractionInfo); - commandMap.put("generalCommissioning", generalCommissioningClusterInteractionInfoMap); - Map generalDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("generalDiagnostics", generalDiagnosticsClusterInteractionInfoMap); - Map groupKeyManagementClusterInteractionInfoMap = new LinkedHashMap<>(); - Map groupKeyManagementkeySetReadCommandParams = new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); - groupKeyManagementkeySetReadCommandParams.put("groupKeySetID",groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetReadInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetRead((ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback - , (Integer) - commandArguments.get("groupKeySetID") - - ); - }, - () -> new DelegatedKeySetReadResponseCallback(), - groupKeyManagementkeySetReadCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetRead", groupKeyManagementkeySetReadInteractionInfo); - Map groupKeyManagementkeySetReadAllIndicesCommandParams = new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = new CommandParameterInfo("groupKeySetIDs", ArrayList.class); - groupKeyManagementkeySetReadAllIndicesCommandParams.put("groupKeySetIDs",groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetReadAllIndices((ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) callback - , (ArrayList) - commandArguments.get("groupKeySetIDs") - - ); - }, - () -> new DelegatedKeySetReadAllIndicesResponseCallback(), - groupKeyManagementkeySetReadAllIndicesCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetReadAllIndices", groupKeyManagementkeySetReadAllIndicesInteractionInfo); - Map groupKeyManagementkeySetRemoveCommandParams = new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); - groupKeyManagementkeySetRemoveCommandParams.put("groupKeySetID",groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetRemove((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("groupKeySetID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupKeyManagementkeySetRemoveCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetRemove", groupKeyManagementkeySetRemoveInteractionInfo); - Map groupKeyManagementkeySetWriteCommandParams = new LinkedHashMap(); - InteractionInfo groupKeyManagementkeySetWriteInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetWrite((DefaultClusterCallback) callback - , (ChipStructs.GroupKeyManagementClusterGroupKeySet) - commandArguments.get("groupKeySet") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupKeyManagementkeySetWriteCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetWrite", groupKeyManagementkeySetWriteInteractionInfo); - commandMap.put("groupKeyManagement", groupKeyManagementClusterInteractionInfoMap); - Map groupsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map groupsaddGroupCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsaddGroupCommandParams.put("groupId",groupsaddGroupgroupIdCommandParameterInfo); - - CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); - groupsaddGroupCommandParams.put("groupName",groupsaddGroupgroupNameCommandParameterInfo); - - InteractionInfo groupsaddGroupInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .addGroup((ChipClusters.GroupsCluster.AddGroupResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (String) - commandArguments.get("groupName") - - ); - }, - () -> new DelegatedAddGroupResponseCallback(), - groupsaddGroupCommandParams - ); - groupsClusterInteractionInfoMap.put("addGroup", groupsaddGroupInteractionInfo); - Map groupsaddGroupIfIdentifyingCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsaddGroupIfIdentifyingCommandParams.put("groupId",groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); - - CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); - groupsaddGroupIfIdentifyingCommandParams.put("groupName",groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); - - InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .addGroupIfIdentifying((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("groupId") - , (String) - commandArguments.get("groupName") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupsaddGroupIfIdentifyingCommandParams - ); - groupsClusterInteractionInfoMap.put("addGroupIfIdentifying", groupsaddGroupIfIdentifyingInteractionInfo); - Map groupsgetGroupMembershipCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = new CommandParameterInfo("groupList", ArrayList.class); - groupsgetGroupMembershipCommandParams.put("groupList",groupsgetGroupMembershipgroupListCommandParameterInfo); - - InteractionInfo groupsgetGroupMembershipInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .getGroupMembership((ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback - , (ArrayList) - commandArguments.get("groupList") - - ); - }, - () -> new DelegatedGetGroupMembershipResponseCallback(), - groupsgetGroupMembershipCommandParams - ); - groupsClusterInteractionInfoMap.put("getGroupMembership", groupsgetGroupMembershipInteractionInfo); - Map groupsremoveAllGroupsCommandParams = new LinkedHashMap(); - InteractionInfo groupsremoveAllGroupsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .removeAllGroups((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupsremoveAllGroupsCommandParams - ); - groupsClusterInteractionInfoMap.put("removeAllGroups", groupsremoveAllGroupsInteractionInfo); - Map groupsremoveGroupCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsremoveGroupCommandParams.put("groupId",groupsremoveGroupgroupIdCommandParameterInfo); - - InteractionInfo groupsremoveGroupInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .removeGroup((ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedRemoveGroupResponseCallback(), - groupsremoveGroupCommandParams - ); - groupsClusterInteractionInfoMap.put("removeGroup", groupsremoveGroupInteractionInfo); - Map groupsviewGroupCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsviewGroupCommandParams.put("groupId",groupsviewGroupgroupIdCommandParameterInfo); - - InteractionInfo groupsviewGroupInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .viewGroup((ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedViewGroupResponseCallback(), - groupsviewGroupCommandParams - ); - groupsClusterInteractionInfoMap.put("viewGroup", groupsviewGroupInteractionInfo); - commandMap.put("groups", groupsClusterInteractionInfoMap); - Map identifyClusterInteractionInfoMap = new LinkedHashMap<>(); - Map identifyidentifyCommandParams = new LinkedHashMap(); - CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("identifyTime", Integer.class); - identifyidentifyCommandParams.put("identifyTime",identifyidentifyidentifyTimeCommandParameterInfo); - - InteractionInfo identifyidentifyInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .identify((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("identifyTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - identifyidentifyCommandParams - ); - identifyClusterInteractionInfoMap.put("identify", identifyidentifyInteractionInfo); - Map identifyidentifyQueryCommandParams = new LinkedHashMap(); - InteractionInfo identifyidentifyQueryInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .identifyQuery((ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback - - ); - }, - () -> new DelegatedIdentifyQueryResponseCallback(), - identifyidentifyQueryCommandParams - ); - identifyClusterInteractionInfoMap.put("identifyQuery", identifyidentifyQueryInteractionInfo); - Map identifytriggerEffectCommandParams = new LinkedHashMap(); - CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = new CommandParameterInfo("effectIdentifier", Integer.class); - identifytriggerEffectCommandParams.put("effectIdentifier",identifytriggerEffecteffectIdentifierCommandParameterInfo); - - CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); - identifytriggerEffectCommandParams.put("effectVariant",identifytriggerEffecteffectVariantCommandParameterInfo); - - InteractionInfo identifytriggerEffectInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .triggerEffect((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("effectIdentifier") - , (Integer) - commandArguments.get("effectVariant") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - identifytriggerEffectCommandParams - ); - identifyClusterInteractionInfoMap.put("triggerEffect", identifytriggerEffectInteractionInfo); - commandMap.put("identify", identifyClusterInteractionInfoMap); - Map illuminanceMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInteractionInfoMap); - Map keypadInputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map keypadInputsendKeyRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = new CommandParameterInfo("keyCode", Integer.class); - keypadInputsendKeyRequestCommandParams.put("keyCode",keypadInputsendKeyRequestkeyCodeCommandParameterInfo); - - InteractionInfo keypadInputsendKeyRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .sendKeyRequest((ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback - , (Integer) - commandArguments.get("keyCode") - - ); - }, - () -> new DelegatedSendKeyResponseCallback(), - keypadInputsendKeyRequestCommandParams - ); - keypadInputClusterInteractionInfoMap.put("sendKeyRequest", keypadInputsendKeyRequestInteractionInfo); - commandMap.put("keypadInput", keypadInputClusterInteractionInfoMap); - Map levelControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map levelControlmoveCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - levelControlmoveCommandParams.put("moveMode",levelControlmovemoveModeCommandParameterInfo); - - CommandParameterInfo levelControlmoverateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - levelControlmoveCommandParams.put("rate",levelControlmoverateCommandParameterInfo); - - CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlmoveCommandParams.put("optionMask",levelControlmoveoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlmoveCommandParams.put("optionOverride",levelControlmoveoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlmoveInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .move((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveCommandParams - ); - levelControlClusterInteractionInfoMap.put("move", levelControlmoveInteractionInfo); - Map levelControlmoveToLevelCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); - levelControlmoveToLevelCommandParams.put("level",levelControlmoveToLevellevelCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlmoveToLevelCommandParams.put("transitionTime",levelControlmoveToLeveltransitionTimeCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlmoveToLevelCommandParams.put("optionMask",levelControlmoveToLeveloptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlmoveToLevelCommandParams.put("optionOverride",levelControlmoveToLeveloptionOverrideCommandParameterInfo); - - InteractionInfo levelControlmoveToLevelInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveToLevel((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("level") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveToLevelCommandParams - ); - levelControlClusterInteractionInfoMap.put("moveToLevel", levelControlmoveToLevelInteractionInfo); - Map levelControlmoveToLevelWithOnOffCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); - levelControlmoveToLevelWithOnOffCommandParams.put("level",levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlmoveToLevelWithOnOffCommandParams.put("transitionTime",levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); - - InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveToLevelWithOnOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("level") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveToLevelWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffInteractionInfo); - Map levelControlmoveWithOnOffCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - levelControlmoveWithOnOffCommandParams.put("moveMode",levelControlmoveWithOnOffmoveModeCommandParameterInfo); - - CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - levelControlmoveWithOnOffCommandParams.put("rate",levelControlmoveWithOnOffrateCommandParameterInfo); - - InteractionInfo levelControlmoveWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveWithOnOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("moveWithOnOff", levelControlmoveWithOnOffInteractionInfo); - Map levelControlstepCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlstepstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - levelControlstepCommandParams.put("stepMode",levelControlstepstepModeCommandParameterInfo); - - CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - levelControlstepCommandParams.put("stepSize",levelControlstepstepSizeCommandParameterInfo); - - CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlstepCommandParams.put("transitionTime",levelControlsteptransitionTimeCommandParameterInfo); - - CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlstepCommandParams.put("optionMask",levelControlstepoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlstepCommandParams.put("optionOverride",levelControlstepoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlstepInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .step((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstepCommandParams - ); - levelControlClusterInteractionInfoMap.put("step", levelControlstepInteractionInfo); - Map levelControlstepWithOnOffCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - levelControlstepWithOnOffCommandParams.put("stepMode",levelControlstepWithOnOffstepModeCommandParameterInfo); - - CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - levelControlstepWithOnOffCommandParams.put("stepSize",levelControlstepWithOnOffstepSizeCommandParameterInfo); - - CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlstepWithOnOffCommandParams.put("transitionTime",levelControlstepWithOnOfftransitionTimeCommandParameterInfo); - - InteractionInfo levelControlstepWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stepWithOnOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstepWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("stepWithOnOff", levelControlstepWithOnOffInteractionInfo); - Map levelControlstopCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlstopCommandParams.put("optionMask",levelControlstopoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlstopCommandParams.put("optionOverride",levelControlstopoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlstopInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stop((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstopCommandParams - ); - levelControlClusterInteractionInfoMap.put("stop", levelControlstopInteractionInfo); - Map levelControlstopWithOnOffCommandParams = new LinkedHashMap(); - InteractionInfo levelControlstopWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stopWithOnOff((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstopWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("stopWithOnOff", levelControlstopWithOnOffInteractionInfo); - commandMap.put("levelControl", levelControlClusterInteractionInfoMap); - Map localizationConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("localizationConfiguration", localizationConfigurationClusterInteractionInfoMap); - Map lowPowerClusterInteractionInfoMap = new LinkedHashMap<>(); - Map lowPowersleepCommandParams = new LinkedHashMap(); - InteractionInfo lowPowersleepInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .sleep((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - lowPowersleepCommandParams - ); - lowPowerClusterInteractionInfoMap.put("sleep", lowPowersleepInteractionInfo); - commandMap.put("lowPower", lowPowerClusterInteractionInfoMap); - Map mediaInputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map mediaInputhideInputStatusRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaInputhideInputStatusRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .hideInputStatusRequest((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputhideInputStatusRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("hideInputStatusRequest", mediaInputhideInputStatusRequestInteractionInfo); - Map mediaInputrenameInputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - mediaInputrenameInputRequestCommandParams.put("index",mediaInputrenameInputRequestindexCommandParameterInfo); - - CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); - mediaInputrenameInputRequestCommandParams.put("name",mediaInputrenameInputRequestnameCommandParameterInfo); - - InteractionInfo mediaInputrenameInputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .renameInputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - , (String) - commandArguments.get("name") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputrenameInputRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("renameInputRequest", mediaInputrenameInputRequestInteractionInfo); - Map mediaInputselectInputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - mediaInputselectInputRequestCommandParams.put("index",mediaInputselectInputRequestindexCommandParameterInfo); - - InteractionInfo mediaInputselectInputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .selectInputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputselectInputRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("selectInputRequest", mediaInputselectInputRequestInteractionInfo); - Map mediaInputshowInputStatusRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaInputshowInputStatusRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .showInputStatusRequest((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputshowInputStatusRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("showInputStatusRequest", mediaInputshowInputStatusRequestInteractionInfo); - commandMap.put("mediaInput", mediaInputClusterInteractionInfoMap); - Map mediaPlaybackClusterInteractionInfoMap = new LinkedHashMap<>(); - Map mediaPlaybackfastForwardRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackfastForwardRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .fastForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackfastForwardRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("fastForwardRequest", mediaPlaybackfastForwardRequestInteractionInfo); - Map mediaPlaybacknextRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybacknextRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .nextRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybacknextRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("nextRequest", mediaPlaybacknextRequestInteractionInfo); - Map mediaPlaybackpauseRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackpauseRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .pauseRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackpauseRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("pauseRequest", mediaPlaybackpauseRequestInteractionInfo); - Map mediaPlaybackplayRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackplayRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .playRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackplayRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("playRequest", mediaPlaybackplayRequestInteractionInfo); - Map mediaPlaybackpreviousRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackpreviousRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .previousRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackpreviousRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("previousRequest", mediaPlaybackpreviousRequestInteractionInfo); - Map mediaPlaybackrewindRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackrewindRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .rewindRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackrewindRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("rewindRequest", mediaPlaybackrewindRequestInteractionInfo); - Map mediaPlaybackseekRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = new CommandParameterInfo("position", Long.class); - mediaPlaybackseekRequestCommandParams.put("position",mediaPlaybackseekRequestpositionCommandParameterInfo); - - InteractionInfo mediaPlaybackseekRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .seekRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - , (Long) - commandArguments.get("position") - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackseekRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("seekRequest", mediaPlaybackseekRequestInteractionInfo); - Map mediaPlaybackskipBackwardRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); - mediaPlaybackskipBackwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); - - InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .skipBackwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - , (Long) - commandArguments.get("deltaPositionMilliseconds") - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackskipBackwardRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("skipBackwardRequest", mediaPlaybackskipBackwardRequestInteractionInfo); - Map mediaPlaybackskipForwardRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); - mediaPlaybackskipForwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); - - InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .skipForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - , (Long) - commandArguments.get("deltaPositionMilliseconds") - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackskipForwardRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("skipForwardRequest", mediaPlaybackskipForwardRequestInteractionInfo); - Map mediaPlaybackstartOverRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackstartOverRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .startOverRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackstartOverRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("startOverRequest", mediaPlaybackstartOverRequestInteractionInfo); - Map mediaPlaybackstopRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackstopRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .stopRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackstopRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("stopRequest", mediaPlaybackstopRequestInteractionInfo); - commandMap.put("mediaPlayback", mediaPlaybackClusterInteractionInfoMap); - Map modeSelectClusterInteractionInfoMap = new LinkedHashMap<>(); - Map modeSelectchangeToModeCommandParams = new LinkedHashMap(); - CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = new CommandParameterInfo("newMode", Integer.class); - modeSelectchangeToModeCommandParams.put("newMode",modeSelectchangeToModenewModeCommandParameterInfo); - - InteractionInfo modeSelectchangeToModeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .changeToMode((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("newMode") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - modeSelectchangeToModeCommandParams - ); - modeSelectClusterInteractionInfoMap.put("changeToMode", modeSelectchangeToModeInteractionInfo); - commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); - Map networkCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); - Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = new CommandParameterInfo("operationalDataset", byte[].class); - networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("operationalDataset",networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .addOrUpdateThreadNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("operationalDataset") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningaddOrUpdateThreadNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("addOrUpdateThreadNetwork", networkCommissioningaddOrUpdateThreadNetworkInteractionInfo); - Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("ssid",networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = new CommandParameterInfo("credentials", byte[].class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("credentials",networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .addOrUpdateWiFiNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("ssid") - , (byte[]) - commandArguments.get("credentials") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningaddOrUpdateWiFiNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("addOrUpdateWiFiNetwork", networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo); - Map networkCommissioningconnectNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); - networkCommissioningconnectNetworkCommandParams.put("networkID",networkCommissioningconnectNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningconnectNetworkCommandParams.put("breadcrumb",networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningconnectNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .connectNetwork((ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback) callback - , (byte[]) - commandArguments.get("networkID") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedConnectNetworkResponseCallback(), - networkCommissioningconnectNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("connectNetwork", networkCommissioningconnectNetworkInteractionInfo); - Map networkCommissioningremoveNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); - networkCommissioningremoveNetworkCommandParams.put("networkID",networkCommissioningremoveNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningremoveNetworkCommandParams.put("breadcrumb",networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningremoveNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .removeNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("networkID") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningremoveNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("removeNetwork", networkCommissioningremoveNetworkInteractionInfo); - Map networkCommissioningreorderNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); - networkCommissioningreorderNetworkCommandParams.put("networkID",networkCommissioningreorderNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = new CommandParameterInfo("networkIndex", Integer.class); - networkCommissioningreorderNetworkCommandParams.put("networkIndex",networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); - - CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningreorderNetworkCommandParams.put("breadcrumb",networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningreorderNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .reorderNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("networkID") - , (Integer) - commandArguments.get("networkIndex") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningreorderNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("reorderNetwork", networkCommissioningreorderNetworkInteractionInfo); - Map networkCommissioningscanNetworksCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); - networkCommissioningscanNetworksCommandParams.put("ssid",networkCommissioningscanNetworksssidCommandParameterInfo); - - CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningscanNetworksCommandParams.put("breadcrumb",networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningscanNetworksInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .scanNetworks((ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback) callback - , (byte[]) - commandArguments.get("ssid") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedScanNetworksResponseCallback(), - networkCommissioningscanNetworksCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("scanNetworks", networkCommissioningscanNetworksInteractionInfo); - commandMap.put("networkCommissioning", networkCommissioningClusterInteractionInfoMap); - Map otaSoftwareUpdateProviderClusterInteractionInfoMap = new LinkedHashMap<>(); - Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("updateToken",otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = new CommandParameterInfo("newVersion", Long.class); - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("newVersion",otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .applyUpdateRequest((ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback) callback - , (byte[]) - commandArguments.get("updateToken") - , (Long) - commandArguments.get("newVersion") - - ); - }, - () -> new DelegatedApplyUpdateResponseCallback(), - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams - ); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put("applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo); - Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("updateToken",otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("softwareVersion",otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .notifyUpdateApplied((DefaultClusterCallback) callback - , (byte[]) - commandArguments.get("updateToken") - , (Long) - commandArguments.get("softwareVersion") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams - ); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put("notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo); - Map otaSoftwareUpdateProviderqueryImageCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("vendorId",otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = new CommandParameterInfo("productId", Integer.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("productId",otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("softwareVersion",otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = new CommandParameterInfo("protocolsSupported", ArrayList.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("protocolsSupported",otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = new CommandParameterInfo("hardwareVersion", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("hardwareVersion",otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = new CommandParameterInfo("location", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("location",otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = new CommandParameterInfo("requestorCanConsent", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("requestorCanConsent",otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = new CommandParameterInfo("metadataForProvider", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("metadataForProvider",otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .queryImage((ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback) callback - , (Integer) - commandArguments.get("vendorId") - , (Integer) - commandArguments.get("productId") - , (Long) - commandArguments.get("softwareVersion") - , (ArrayList) - commandArguments.get("protocolsSupported") - , (Optional) - commandArguments.get("hardwareVersion") - , (Optional) - commandArguments.get("location") - , (Optional) - commandArguments.get("requestorCanConsent") - , (Optional) - commandArguments.get("metadataForProvider") - - ); - }, - () -> new DelegatedQueryImageResponseCallback(), - otaSoftwareUpdateProviderqueryImageCommandParams - ); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put("queryImage", otaSoftwareUpdateProviderqueryImageInteractionInfo); - commandMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInteractionInfoMap); - Map otaSoftwareUpdateRequestorClusterInteractionInfoMap = new LinkedHashMap<>(); - Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = new CommandParameterInfo("providerNodeId", Long.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("providerNodeId",otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("vendorId",otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = new CommandParameterInfo("announcementReason", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("announcementReason",otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = new CommandParameterInfo("metadataForNode", Optional.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("metadataForNode",otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = new CommandParameterInfo("endpoint", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("endpoint",otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .announceOtaProvider((DefaultClusterCallback) callback - , (Long) - commandArguments.get("providerNodeId") - , (Integer) - commandArguments.get("vendorId") - , (Integer) - commandArguments.get("announcementReason") - , (Optional) - commandArguments.get("metadataForNode") - , (Integer) - commandArguments.get("endpoint") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams - ); - otaSoftwareUpdateRequestorClusterInteractionInfoMap.put("announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo); - commandMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInteractionInfoMap); - Map occupancySensingClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("occupancySensing", occupancySensingClusterInteractionInfoMap); - Map onOffClusterInteractionInfoMap = new LinkedHashMap<>(); - Map onOffoffCommandParams = new LinkedHashMap(); - InteractionInfo onOffoffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .off((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffoffCommandParams - ); - onOffClusterInteractionInfoMap.put("off", onOffoffInteractionInfo); - Map onOffoffWithEffectCommandParams = new LinkedHashMap(); - CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = new CommandParameterInfo("effectId", Integer.class); - onOffoffWithEffectCommandParams.put("effectId",onOffoffWithEffecteffectIdCommandParameterInfo); - - CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); - onOffoffWithEffectCommandParams.put("effectVariant",onOffoffWithEffecteffectVariantCommandParameterInfo); - - InteractionInfo onOffoffWithEffectInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .offWithEffect((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("effectId") - , (Integer) - commandArguments.get("effectVariant") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffoffWithEffectCommandParams - ); - onOffClusterInteractionInfoMap.put("offWithEffect", onOffoffWithEffectInteractionInfo); - Map onOffonCommandParams = new LinkedHashMap(); - InteractionInfo onOffonInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .on((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonCommandParams - ); - onOffClusterInteractionInfoMap.put("on", onOffonInteractionInfo); - Map onOffonWithRecallGlobalSceneCommandParams = new LinkedHashMap(); - InteractionInfo onOffonWithRecallGlobalSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .onWithRecallGlobalScene((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonWithRecallGlobalSceneCommandParams - ); - onOffClusterInteractionInfoMap.put("onWithRecallGlobalScene", onOffonWithRecallGlobalSceneInteractionInfo); - Map onOffonWithTimedOffCommandParams = new LinkedHashMap(); - CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = new CommandParameterInfo("onOffControl", Integer.class); - onOffonWithTimedOffCommandParams.put("onOffControl",onOffonWithTimedOffonOffControlCommandParameterInfo); - - CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = new CommandParameterInfo("onTime", Integer.class); - onOffonWithTimedOffCommandParams.put("onTime",onOffonWithTimedOffonTimeCommandParameterInfo); - - CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("offWaitTime", Integer.class); - onOffonWithTimedOffCommandParams.put("offWaitTime",onOffonWithTimedOffoffWaitTimeCommandParameterInfo); - - InteractionInfo onOffonWithTimedOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .onWithTimedOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("onOffControl") - , (Integer) - commandArguments.get("onTime") - , (Integer) - commandArguments.get("offWaitTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonWithTimedOffCommandParams - ); - onOffClusterInteractionInfoMap.put("onWithTimedOff", onOffonWithTimedOffInteractionInfo); - Map onOfftoggleCommandParams = new LinkedHashMap(); - InteractionInfo onOfftoggleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .toggle((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOfftoggleCommandParams - ); - onOffClusterInteractionInfoMap.put("toggle", onOfftoggleInteractionInfo); - commandMap.put("onOff", onOffClusterInteractionInfoMap); - Map onOffSwitchConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInteractionInfoMap); - Map operationalCredentialsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map operationalCredentialsaddNOCCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); - operationalCredentialsaddNOCCommandParams.put("NOCValue",operationalCredentialsaddNOCNOCValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); - operationalCredentialsaddNOCCommandParams.put("ICACValue",operationalCredentialsaddNOCICACValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = new CommandParameterInfo("IPKValue", byte[].class); - operationalCredentialsaddNOCCommandParams.put("IPKValue",operationalCredentialsaddNOCIPKValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = new CommandParameterInfo("caseAdminNode", Long.class); - operationalCredentialsaddNOCCommandParams.put("caseAdminNode",operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = new CommandParameterInfo("adminVendorId", Integer.class); - operationalCredentialsaddNOCCommandParams.put("adminVendorId",operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); - - InteractionInfo operationalCredentialsaddNOCInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .addNOC((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (byte[]) - commandArguments.get("NOCValue") - , (Optional) - commandArguments.get("ICACValue") - , (byte[]) - commandArguments.get("IPKValue") - , (Long) - commandArguments.get("caseAdminNode") - , (Integer) - commandArguments.get("adminVendorId") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsaddNOCCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("addNOC", operationalCredentialsaddNOCInteractionInfo); - Map operationalCredentialsaddTrustedRootCertificateCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = new CommandParameterInfo("rootCertificate", byte[].class); - operationalCredentialsaddTrustedRootCertificateCommandParams.put("rootCertificate",operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); - - InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .addTrustedRootCertificate((DefaultClusterCallback) callback - , (byte[]) - commandArguments.get("rootCertificate") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - operationalCredentialsaddTrustedRootCertificateCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("addTrustedRootCertificate", operationalCredentialsaddTrustedRootCertificateInteractionInfo); - Map operationalCredentialsattestationRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = new CommandParameterInfo("attestationNonce", byte[].class); - operationalCredentialsattestationRequestCommandParams.put("attestationNonce",operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); - - InteractionInfo operationalCredentialsattestationRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .attestationRequest((ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) callback - , (byte[]) - commandArguments.get("attestationNonce") - - ); - }, - () -> new DelegatedAttestationResponseCallback(), - operationalCredentialsattestationRequestCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("attestationRequest", operationalCredentialsattestationRequestInteractionInfo); - Map operationalCredentialscertificateChainRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = new CommandParameterInfo("certificateType", Integer.class); - operationalCredentialscertificateChainRequestCommandParams.put("certificateType",operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); - - InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .certificateChainRequest((ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) callback - , (Integer) - commandArguments.get("certificateType") - - ); - }, - () -> new DelegatedCertificateChainResponseCallback(), - operationalCredentialscertificateChainRequestCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("certificateChainRequest", operationalCredentialscertificateChainRequestInteractionInfo); - Map operationalCredentialsopCSRRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = new CommandParameterInfo("CSRNonce", byte[].class); - operationalCredentialsopCSRRequestCommandParams.put("CSRNonce",operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); - - InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .opCSRRequest((ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback - , (byte[]) - commandArguments.get("CSRNonce") - - ); - }, - () -> new DelegatedOpCSRResponseCallback(), - operationalCredentialsopCSRRequestCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("opCSRRequest", operationalCredentialsopCSRRequestInteractionInfo); - Map operationalCredentialsremoveFabricCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = new CommandParameterInfo("fabricIndex", Integer.class); - operationalCredentialsremoveFabricCommandParams.put("fabricIndex",operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); - - InteractionInfo operationalCredentialsremoveFabricInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .removeFabric((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (Integer) - commandArguments.get("fabricIndex") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsremoveFabricCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("removeFabric", operationalCredentialsremoveFabricInteractionInfo); - Map operationalCredentialsremoveTrustedRootCertificateCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = new CommandParameterInfo("trustedRootIdentifier", byte[].class); - operationalCredentialsremoveTrustedRootCertificateCommandParams.put("trustedRootIdentifier",operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); - - InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .removeTrustedRootCertificate((DefaultClusterCallback) callback - , (byte[]) - commandArguments.get("trustedRootIdentifier") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - operationalCredentialsremoveTrustedRootCertificateCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("removeTrustedRootCertificate", operationalCredentialsremoveTrustedRootCertificateInteractionInfo); - Map operationalCredentialsupdateFabricLabelCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = new CommandParameterInfo("label", String.class); - operationalCredentialsupdateFabricLabelCommandParams.put("label",operationalCredentialsupdateFabricLabellabelCommandParameterInfo); - - InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .updateFabricLabel((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (String) - commandArguments.get("label") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsupdateFabricLabelCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("updateFabricLabel", operationalCredentialsupdateFabricLabelInteractionInfo); - Map operationalCredentialsupdateNOCCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); - operationalCredentialsupdateNOCCommandParams.put("NOCValue",operationalCredentialsupdateNOCNOCValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); - operationalCredentialsupdateNOCCommandParams.put("ICACValue",operationalCredentialsupdateNOCICACValueCommandParameterInfo); - - InteractionInfo operationalCredentialsupdateNOCInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .updateNOC((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (byte[]) - commandArguments.get("NOCValue") - , (Optional) - commandArguments.get("ICACValue") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsupdateNOCCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("updateNOC", operationalCredentialsupdateNOCInteractionInfo); - commandMap.put("operationalCredentials", operationalCredentialsClusterInteractionInfoMap); - Map powerSourceClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("powerSource", powerSourceClusterInteractionInfoMap); - Map powerSourceConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInteractionInfoMap); - Map pressureMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("pressureMeasurement", pressureMeasurementClusterInteractionInfoMap); - Map pumpConfigurationAndControlClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInteractionInfoMap); - Map relativeHumidityMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInteractionInfoMap); - Map scenesClusterInteractionInfoMap = new LinkedHashMap<>(); - Map scenesaddSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesaddSceneCommandParams.put("groupId",scenesaddScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesaddSceneCommandParams.put("sceneId",scenesaddScenesceneIdCommandParameterInfo); - - CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - scenesaddSceneCommandParams.put("transitionTime",scenesaddScenetransitionTimeCommandParameterInfo); - - CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = new CommandParameterInfo("sceneName", String.class); - scenesaddSceneCommandParams.put("sceneName",scenesaddScenesceneNameCommandParameterInfo); - - InteractionInfo scenesaddSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .addScene((ChipClusters.ScenesCluster.AddSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - , (Integer) - commandArguments.get("transitionTime") - , (String) - commandArguments.get("sceneName") - , (ArrayList) - commandArguments.get("extensionFieldSets") - - ); - }, - () -> new DelegatedAddSceneResponseCallback(), - scenesaddSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("addScene", scenesaddSceneInteractionInfo); - Map scenesgetSceneMembershipCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesgetSceneMembershipCommandParams.put("groupId",scenesgetSceneMembershipgroupIdCommandParameterInfo); - - InteractionInfo scenesgetSceneMembershipInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .getSceneMembership((ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedGetSceneMembershipResponseCallback(), - scenesgetSceneMembershipCommandParams - ); - scenesClusterInteractionInfoMap.put("getSceneMembership", scenesgetSceneMembershipInteractionInfo); - Map scenesrecallSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesrecallSceneCommandParams.put("groupId",scenesrecallScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesrecallSceneCommandParams.put("sceneId",scenesrecallScenesceneIdCommandParameterInfo); - - CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - scenesrecallSceneCommandParams.put("transitionTime",scenesrecallScenetransitionTimeCommandParameterInfo); - - InteractionInfo scenesrecallSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .recallScene((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - scenesrecallSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("recallScene", scenesrecallSceneInteractionInfo); - Map scenesremoveAllScenesCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesremoveAllScenesCommandParams.put("groupId",scenesremoveAllScenesgroupIdCommandParameterInfo); - - InteractionInfo scenesremoveAllScenesInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .removeAllScenes((ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedRemoveAllScenesResponseCallback(), - scenesremoveAllScenesCommandParams - ); - scenesClusterInteractionInfoMap.put("removeAllScenes", scenesremoveAllScenesInteractionInfo); - Map scenesremoveSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesremoveSceneCommandParams.put("groupId",scenesremoveScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesremoveSceneCommandParams.put("sceneId",scenesremoveScenesceneIdCommandParameterInfo); - - InteractionInfo scenesremoveSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .removeScene((ChipClusters.ScenesCluster.RemoveSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - - ); - }, - () -> new DelegatedRemoveSceneResponseCallback(), - scenesremoveSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("removeScene", scenesremoveSceneInteractionInfo); - Map scenesstoreSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesstoreSceneCommandParams.put("groupId",scenesstoreScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesstoreSceneCommandParams.put("sceneId",scenesstoreScenesceneIdCommandParameterInfo); - - InteractionInfo scenesstoreSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .storeScene((ChipClusters.ScenesCluster.StoreSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - - ); - }, - () -> new DelegatedStoreSceneResponseCallback(), - scenesstoreSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("storeScene", scenesstoreSceneInteractionInfo); - Map scenesviewSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesviewSceneCommandParams.put("groupId",scenesviewScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesviewSceneCommandParams.put("sceneId",scenesviewScenesceneIdCommandParameterInfo); - - InteractionInfo scenesviewSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .viewScene((ChipClusters.ScenesCluster.ViewSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - - ); - }, - () -> new DelegatedViewSceneResponseCallback(), - scenesviewSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("viewScene", scenesviewSceneInteractionInfo); - commandMap.put("scenes", scenesClusterInteractionInfoMap); - Map softwareDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map softwareDiagnosticsresetWatermarksCommandParams = new LinkedHashMap(); - InteractionInfo softwareDiagnosticsresetWatermarksInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .resetWatermarks((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - softwareDiagnosticsresetWatermarksCommandParams - ); - softwareDiagnosticsClusterInteractionInfoMap.put("resetWatermarks", softwareDiagnosticsresetWatermarksInteractionInfo); - commandMap.put("softwareDiagnostics", softwareDiagnosticsClusterInteractionInfoMap); - Map switchClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("switch", switchClusterInteractionInfoMap); - Map targetNavigatorClusterInteractionInfoMap = new LinkedHashMap<>(); - Map targetNavigatornavigateTargetRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = new CommandParameterInfo("target", Integer.class); - targetNavigatornavigateTargetRequestCommandParams.put("target",targetNavigatornavigateTargetRequesttargetCommandParameterInfo); - - CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); - targetNavigatornavigateTargetRequestCommandParams.put("data",targetNavigatornavigateTargetRequestdataCommandParameterInfo); - - InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .navigateTargetRequest((ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback) callback - , (Integer) - commandArguments.get("target") - , (String) - commandArguments.get("data") - - ); - }, - () -> new DelegatedNavigateTargetResponseCallback(), - targetNavigatornavigateTargetRequestCommandParams - ); - targetNavigatorClusterInteractionInfoMap.put("navigateTargetRequest", targetNavigatornavigateTargetRequestInteractionInfo); - commandMap.put("targetNavigator", targetNavigatorClusterInteractionInfoMap); - Map temperatureMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); - Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); - Map testClustersimpleStructEchoRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustersimpleStructEchoRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .simpleStructEchoRequest((ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback - , (ChipStructs.TestClusterClusterSimpleStruct) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedSimpleStructResponseCallback(), - testClustersimpleStructEchoRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("simpleStructEchoRequest", testClustersimpleStructEchoRequestInteractionInfo); - Map testClustertestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .test((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestCommandParams - ); - testClusterClusterInteractionInfoMap.put("test", testClustertestInteractionInfo); - Map testClustertestAddArgumentsCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); - testClustertestAddArgumentsCommandParams.put("arg1",testClustertestAddArgumentsarg1CommandParameterInfo); - - CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); - testClustertestAddArgumentsCommandParams.put("arg2",testClustertestAddArgumentsarg2CommandParameterInfo); - - InteractionInfo testClustertestAddArgumentsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testAddArguments((ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback) callback - , (Integer) - commandArguments.get("arg1") - , (Integer) - commandArguments.get("arg2") - - ); - }, - () -> new DelegatedTestAddArgumentsResponseCallback(), - testClustertestAddArgumentsCommandParams - ); - testClusterClusterInteractionInfoMap.put("testAddArguments", testClustertestAddArgumentsInteractionInfo); - Map testClustertestEmitTestEventRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); - testClustertestEmitTestEventRequestCommandParams.put("arg1",testClustertestEmitTestEventRequestarg1CommandParameterInfo); - - CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); - testClustertestEmitTestEventRequestCommandParams.put("arg2",testClustertestEmitTestEventRequestarg2CommandParameterInfo); - - CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = new CommandParameterInfo("arg3", Boolean.class); - testClustertestEmitTestEventRequestCommandParams.put("arg3",testClustertestEmitTestEventRequestarg3CommandParameterInfo); - - InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testEmitTestEventRequest((ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback) callback - , (Integer) - commandArguments.get("arg1") - , (Integer) - commandArguments.get("arg2") - , (Boolean) - commandArguments.get("arg3") - - ); - }, - () -> new DelegatedTestEmitTestEventResponseCallback(), - testClustertestEmitTestEventRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testEmitTestEventRequest", testClustertestEmitTestEventRequestInteractionInfo); - Map testClustertestEnumsRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); - testClustertestEnumsRequestCommandParams.put("arg1",testClustertestEnumsRequestarg1CommandParameterInfo); - - CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); - testClustertestEnumsRequestCommandParams.put("arg2",testClustertestEnumsRequestarg2CommandParameterInfo); - - InteractionInfo testClustertestEnumsRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testEnumsRequest((ChipClusters.TestClusterCluster.TestEnumsResponseCallback) callback - , (Integer) - commandArguments.get("arg1") - , (Integer) - commandArguments.get("arg2") - - ); - }, - () -> new DelegatedTestEnumsResponseCallback(), - testClustertestEnumsRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testEnumsRequest", testClustertestEnumsRequestInteractionInfo); - Map testClustertestListInt8UArgumentRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); - testClustertestListInt8UArgumentRequestCommandParams.put("arg1",testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListInt8UArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListInt8UArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestInteractionInfo); - Map testClustertestListInt8UReverseRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); - testClustertestListInt8UReverseRequestCommandParams.put("arg1",testClustertestListInt8UReverseRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListInt8UReverseRequest((ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedTestListInt8UReverseResponseCallback(), - testClustertestListInt8UReverseRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListInt8UReverseRequest", testClustertestListInt8UReverseRequestInteractionInfo); - Map testClustertestListNestedStructListArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestListNestedStructListArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListNestedStructListArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListNestedStructListArgumentRequest", testClustertestListNestedStructListArgumentRequestInteractionInfo); - Map testClustertestListStructArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListStructArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListStructArgumentRequest", testClustertestListStructArgumentRequestInteractionInfo); - Map testClustertestNestedStructArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestNestedStructArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNestedStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ChipStructs.TestClusterClusterNestedStruct) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestNestedStructArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNestedStructArgumentRequest", testClustertestNestedStructArgumentRequestInteractionInfo); - Map testClustertestNestedStructListArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestNestedStructListArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ChipStructs.TestClusterClusterNestedStructList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestNestedStructListArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNestedStructListArgumentRequest", testClustertestNestedStructListArgumentRequestInteractionInfo); - Map testClustertestNotHandledCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestNotHandledInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNotHandled((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestNotHandledCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNotHandled", testClustertestNotHandledInteractionInfo); - Map testClustertestNullableOptionalRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); - testClustertestNullableOptionalRequestCommandParams.put("arg1",testClustertestNullableOptionalRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNullableOptionalRequest((ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) callback - , (Optional) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedTestNullableOptionalResponseCallback(), - testClustertestNullableOptionalRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNullableOptionalRequest", testClustertestNullableOptionalRequestInteractionInfo); - Map testClustertestSimpleOptionalArgumentRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); - testClustertestSimpleOptionalArgumentRequestCommandParams.put("arg1",testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testSimpleOptionalArgumentRequest((DefaultClusterCallback) callback - , (Optional) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestSimpleOptionalArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testSimpleOptionalArgumentRequest", testClustertestSimpleOptionalArgumentRequestInteractionInfo); - Map testClustertestSpecificCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestSpecificInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testSpecific((ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback - - ); - }, - () -> new DelegatedTestSpecificResponseCallback(), - testClustertestSpecificCommandParams - ); - testClusterClusterInteractionInfoMap.put("testSpecific", testClustertestSpecificInteractionInfo); - Map testClustertestStructArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestStructArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ChipStructs.TestClusterClusterSimpleStruct) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestStructArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testStructArgumentRequest", testClustertestStructArgumentRequestInteractionInfo); - Map testClustertestUnknownCommandCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestUnknownCommandInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testUnknownCommand((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestUnknownCommandCommandParams - ); - testClusterClusterInteractionInfoMap.put("testUnknownCommand", testClustertestUnknownCommandInteractionInfo); - Map testClustertimedInvokeRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertimedInvokeRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .timedInvokeRequest((DefaultClusterCallback) callback - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertimedInvokeRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("timedInvokeRequest", testClustertimedInvokeRequestInteractionInfo); - commandMap.put("testCluster", testClusterClusterInteractionInfoMap); - Map thermostatClusterInteractionInfoMap = new LinkedHashMap<>(); - Map thermostatclearWeeklyScheduleCommandParams = new LinkedHashMap(); - InteractionInfo thermostatclearWeeklyScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .clearWeeklySchedule((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatclearWeeklyScheduleCommandParams - ); - thermostatClusterInteractionInfoMap.put("clearWeeklySchedule", thermostatclearWeeklyScheduleInteractionInfo); - Map thermostatgetRelayStatusLogCommandParams = new LinkedHashMap(); - InteractionInfo thermostatgetRelayStatusLogInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .getRelayStatusLog((ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback - - ); - }, - () -> new DelegatedGetRelayStatusLogResponseCallback(), - thermostatgetRelayStatusLogCommandParams - ); - thermostatClusterInteractionInfoMap.put("getRelayStatusLog", thermostatgetRelayStatusLogInteractionInfo); - Map thermostatgetWeeklyScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = new CommandParameterInfo("daysToReturn", Integer.class); - thermostatgetWeeklyScheduleCommandParams.put("daysToReturn",thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); - - CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = new CommandParameterInfo("modeToReturn", Integer.class); - thermostatgetWeeklyScheduleCommandParams.put("modeToReturn",thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); - - InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .getWeeklySchedule((ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback) callback - , (Integer) - commandArguments.get("daysToReturn") - , (Integer) - commandArguments.get("modeToReturn") - - ); - }, - () -> new DelegatedGetWeeklyScheduleResponseCallback(), - thermostatgetWeeklyScheduleCommandParams - ); - thermostatClusterInteractionInfoMap.put("getWeeklySchedule", thermostatgetWeeklyScheduleInteractionInfo); - Map thermostatsetWeeklyScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put("numberOfTransitionsForSequence",thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = new CommandParameterInfo("dayOfWeekForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put("dayOfWeekForSequence",thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = new CommandParameterInfo("modeForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put("modeForSequence",thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = new CommandParameterInfo("payload", ArrayList.class); - thermostatsetWeeklyScheduleCommandParams.put("payload",thermostatsetWeeklySchedulepayloadCommandParameterInfo); - - InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .setWeeklySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("numberOfTransitionsForSequence") - , (Integer) - commandArguments.get("dayOfWeekForSequence") - , (Integer) - commandArguments.get("modeForSequence") - , (ArrayList) - commandArguments.get("payload") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatsetWeeklyScheduleCommandParams - ); - thermostatClusterInteractionInfoMap.put("setWeeklySchedule", thermostatsetWeeklyScheduleInteractionInfo); - Map thermostatsetpointRaiseLowerCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = new CommandParameterInfo("mode", Integer.class); - thermostatsetpointRaiseLowerCommandParams.put("mode",thermostatsetpointRaiseLowermodeCommandParameterInfo); - - CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = new CommandParameterInfo("amount", Integer.class); - thermostatsetpointRaiseLowerCommandParams.put("amount",thermostatsetpointRaiseLoweramountCommandParameterInfo); - - InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .setpointRaiseLower((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("mode") - , (Integer) - commandArguments.get("amount") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatsetpointRaiseLowerCommandParams - ); - thermostatClusterInteractionInfoMap.put("setpointRaiseLower", thermostatsetpointRaiseLowerInteractionInfo); - commandMap.put("thermostat", thermostatClusterInteractionInfoMap); - Map thermostatUserInterfaceConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInteractionInfoMap); - Map threadNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map threadNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); - InteractionInfo threadNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - threadNetworkDiagnosticsresetCountsCommandParams - ); - threadNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", threadNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInteractionInfoMap); - Map timeFormatLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("timeFormatLocalization", timeFormatLocalizationClusterInteractionInfoMap); - Map unitLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("unitLocalization", unitLocalizationClusterInteractionInfoMap); - Map userLabelClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("userLabel", userLabelClusterInteractionInfoMap); - Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); - Map wiFiNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map wiFiNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); - InteractionInfo wiFiNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - wiFiNetworkDiagnosticsresetCountsCommandParams - ); - wiFiNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", wiFiNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInteractionInfoMap); - Map windowCoveringClusterInteractionInfoMap = new LinkedHashMap<>(); - Map windowCoveringdownOrCloseCommandParams = new LinkedHashMap(); - InteractionInfo windowCoveringdownOrCloseInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .downOrClose((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringdownOrCloseCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("downOrClose", windowCoveringdownOrCloseInteractionInfo); - Map windowCoveringgoToLiftPercentageCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = new CommandParameterInfo("liftPercentageValue", Integer.class); - windowCoveringgoToLiftPercentageCommandParams.put("liftPercentageValue",windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); - - CommandParameterInfo windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = new CommandParameterInfo("liftPercent100thsValue", Integer.class); - windowCoveringgoToLiftPercentageCommandParams.put("liftPercent100thsValue",windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToLiftPercentage((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("liftPercentageValue") - , (Integer) - commandArguments.get("liftPercent100thsValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToLiftPercentageCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToLiftPercentage", windowCoveringgoToLiftPercentageInteractionInfo); - Map windowCoveringgoToLiftValueCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = new CommandParameterInfo("liftValue", Integer.class); - windowCoveringgoToLiftValueCommandParams.put("liftValue",windowCoveringgoToLiftValueliftValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToLiftValueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToLiftValue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("liftValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToLiftValueCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToLiftValue", windowCoveringgoToLiftValueInteractionInfo); - Map windowCoveringgoToTiltPercentageCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = new CommandParameterInfo("tiltPercentageValue", Integer.class); - windowCoveringgoToTiltPercentageCommandParams.put("tiltPercentageValue",windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); - - CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = new CommandParameterInfo("tiltPercent100thsValue", Integer.class); - windowCoveringgoToTiltPercentageCommandParams.put("tiltPercent100thsValue",windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToTiltPercentage((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("tiltPercentageValue") - , (Integer) - commandArguments.get("tiltPercent100thsValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToTiltPercentageCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToTiltPercentage", windowCoveringgoToTiltPercentageInteractionInfo); - Map windowCoveringgoToTiltValueCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = new CommandParameterInfo("tiltValue", Integer.class); - windowCoveringgoToTiltValueCommandParams.put("tiltValue",windowCoveringgoToTiltValuetiltValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToTiltValueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToTiltValue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("tiltValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToTiltValueCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToTiltValue", windowCoveringgoToTiltValueInteractionInfo); - Map windowCoveringstopMotionCommandParams = new LinkedHashMap(); - InteractionInfo windowCoveringstopMotionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .stopMotion((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringstopMotionCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("stopMotion", windowCoveringstopMotionInteractionInfo); - Map windowCoveringupOrOpenCommandParams = new LinkedHashMap(); - InteractionInfo windowCoveringupOrOpenInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .upOrOpen((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringupOrOpenCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("upOrOpen", windowCoveringupOrOpenInteractionInfo); - commandMap.put("windowCovering", windowCoveringClusterInteractionInfoMap); - return commandMap; + @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 DelegatedAccessControlClusterExtensionAttributeCallback + implements ChipClusters.AccessControlCluster.ExtensionAttributeCallback, + 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 DelegatedAccessControlClusterAttributeListAttributeCallback + implements ChipClusters.AccessControlCluster.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 DelegatedGetSetupPINResponseCallback + implements ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(String setupPIN) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("setupPIN", "String"); + responseValues.put(setupPINResponseValue, setupPIN); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedAccountLoginClusterAttributeListAttributeCallback + implements ChipClusters.AccountLoginCluster.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 DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback + implements ChipClusters.AdministratorCommissioningCluster.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 DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback + implements ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback, + 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 DelegatedApplicationBasicClusterAttributeListAttributeCallback + implements ChipClusters.ApplicationBasicCluster.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 DelegatedLauncherResponseCallback + implements ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback + implements ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback, + 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 DelegatedApplicationLauncherClusterAttributeListAttributeCallback + implements ChipClusters.ApplicationLauncherCluster.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 DelegatedAudioOutputClusterAudioOutputListAttributeCallback + implements ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback, + 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 DelegatedAudioOutputClusterAttributeListAttributeCallback + implements ChipClusters.AudioOutputCluster.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 DelegatedBarrierControlClusterAttributeListAttributeCallback + implements ChipClusters.BarrierControlCluster.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 DelegatedBasicClusterAttributeListAttributeCallback + implements ChipClusters.BasicCluster.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 DelegatedBinaryInputBasicClusterAttributeListAttributeCallback + implements ChipClusters.BinaryInputBasicCluster.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 DelegatedBindingClusterAttributeListAttributeCallback + implements ChipClusters.BindingCluster.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 DelegatedBooleanStateClusterAttributeListAttributeCallback + implements ChipClusters.BooleanStateCluster.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 DelegatedBridgedActionsClusterActionListAttributeCallback + implements ChipClusters.BridgedActionsCluster.ActionListAttributeCallback, + 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 DelegatedBridgedActionsClusterEndpointListAttributeCallback + implements ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback, + 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 DelegatedBridgedActionsClusterAttributeListAttributeCallback + implements ChipClusters.BridgedActionsCluster.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 DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback + implements ChipClusters.BridgedDeviceBasicCluster.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 DelegatedChangeChannelResponseCallback + implements ChipClusters.ChannelCluster.ChangeChannelResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType) { + Map responseValues = new LinkedHashMap<>(); + // channelMatch: Struct ChannelInfo + // Conversion from this type to Java is not properly implemented yet + CommandResponseInfo errorTypeResponseValue = new CommandResponseInfo("errorType", "Integer"); + responseValues.put(errorTypeResponseValue, errorType); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedChannelClusterChannelListAttributeCallback + implements ChipClusters.ChannelCluster.ChannelListAttributeCallback, + 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 DelegatedChannelClusterAttributeListAttributeCallback + implements ChipClusters.ChannelCluster.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 DelegatedColorControlClusterAttributeListAttributeCallback + implements ChipClusters.ColorControlCluster.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 DelegatedLaunchResponseCallback + implements ChipClusters.ContentLauncherCluster.LaunchResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback + implements ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback, + 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 DelegatedContentLauncherClusterAttributeListAttributeCallback + implements ChipClusters.ContentLauncherCluster.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 DelegatedDescriptorClusterDeviceListAttributeCallback + implements ChipClusters.DescriptorCluster.DeviceListAttributeCallback, + 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 DelegatedDescriptorClusterServerListAttributeCallback + implements ChipClusters.DescriptorCluster.ServerListAttributeCallback, + 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 DelegatedDescriptorClusterClientListAttributeCallback + implements ChipClusters.DescriptorCluster.ClientListAttributeCallback, + 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 DelegatedDescriptorClusterPartsListAttributeCallback + implements ChipClusters.DescriptorCluster.PartsListAttributeCallback, + 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 DelegatedDescriptorClusterAttributeListAttributeCallback + implements ChipClusters.DescriptorCluster.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 DelegatedRetrieveLogsResponseCallback + implements ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo contentResponseValue = new CommandResponseInfo("content", "byte[]"); + responseValues.put(contentResponseValue, content); + CommandResponseInfo timeStampResponseValue = new CommandResponseInfo("timeStamp", "Long"); + responseValues.put(timeStampResponseValue, timeStamp); + CommandResponseInfo timeSinceBootResponseValue = + new CommandResponseInfo("timeSinceBoot", "Long"); + responseValues.put(timeSinceBootResponseValue, timeSinceBoot); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedDiagnosticLogsClusterAttributeListAttributeCallback + implements ChipClusters.DiagnosticLogsCluster.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 DelegatedGetCredentialStatusResponseCallback + implements ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Boolean credentialExists, + @Nullable Integer userIndex, + @Nullable Integer nextCredentialIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo credentialExistsResponseValue = + new CommandResponseInfo("credentialExists", "Boolean"); + responseValues.put(credentialExistsResponseValue, credentialExists); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo nextCredentialIndexResponseValue = + new CommandResponseInfo("nextCredentialIndex", "Integer"); + responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetUserResponseCallback + implements ChipClusters.DoorLockCluster.GetUserResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + @Nullable ArrayList credentials, + @Nullable Integer creatorFabricIndex, + @Nullable Integer lastModifiedFabricIndex, + @Nullable Integer nextUserIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo userNameResponseValue = new CommandResponseInfo("userName", "String"); + responseValues.put(userNameResponseValue, userName); + CommandResponseInfo userUniqueIdResponseValue = + new CommandResponseInfo("userUniqueId", "Long"); + responseValues.put(userUniqueIdResponseValue, userUniqueId); + CommandResponseInfo userStatusResponseValue = + new CommandResponseInfo("userStatus", "Integer"); + responseValues.put(userStatusResponseValue, userStatus); + CommandResponseInfo userTypeResponseValue = new CommandResponseInfo("userType", "Integer"); + responseValues.put(userTypeResponseValue, userType); + CommandResponseInfo credentialRuleResponseValue = + new CommandResponseInfo("credentialRule", "Integer"); + responseValues.put(credentialRuleResponseValue, credentialRule); + // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + CommandResponseInfo creatorFabricIndexResponseValue = + new CommandResponseInfo("creatorFabricIndex", "Integer"); + responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); + CommandResponseInfo lastModifiedFabricIndexResponseValue = + new CommandResponseInfo("lastModifiedFabricIndex", "Integer"); + responseValues.put(lastModifiedFabricIndexResponseValue, lastModifiedFabricIndex); + CommandResponseInfo nextUserIndexResponseValue = + new CommandResponseInfo("nextUserIndex", "Integer"); + responseValues.put(nextUserIndexResponseValue, nextUserIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetWeekDayScheduleResponseCallback + implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer weekDayIndex, + Integer userIndex, + Integer status, + Optional daysMask, + Optional startHour, + Optional startMinute, + Optional endHour, + Optional endMinute) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo weekDayIndexResponseValue = + new CommandResponseInfo("weekDayIndex", "Integer"); + responseValues.put(weekDayIndexResponseValue, weekDayIndex); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo daysMaskResponseValue = + new CommandResponseInfo("daysMask", "Optional"); + responseValues.put(daysMaskResponseValue, daysMask); + CommandResponseInfo startHourResponseValue = + new CommandResponseInfo("startHour", "Optional"); + responseValues.put(startHourResponseValue, startHour); + CommandResponseInfo startMinuteResponseValue = + new CommandResponseInfo("startMinute", "Optional"); + responseValues.put(startMinuteResponseValue, startMinute); + CommandResponseInfo endHourResponseValue = + new CommandResponseInfo("endHour", "Optional"); + responseValues.put(endHourResponseValue, endHour); + CommandResponseInfo endMinuteResponseValue = + new CommandResponseInfo("endMinute", "Optional"); + responseValues.put(endMinuteResponseValue, endMinute); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetYearDayScheduleResponseCallback + implements ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer yearDayIndex, + Integer userIndex, + Integer status, + Optional localStartTime, + Optional localEndTime) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo yearDayIndexResponseValue = + new CommandResponseInfo("yearDayIndex", "Integer"); + responseValues.put(yearDayIndexResponseValue, yearDayIndex); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo localStartTimeResponseValue = + new CommandResponseInfo("localStartTime", "Optional"); + responseValues.put(localStartTimeResponseValue, localStartTime); + CommandResponseInfo localEndTimeResponseValue = + new CommandResponseInfo("localEndTime", "Optional"); + responseValues.put(localEndTimeResponseValue, localEndTime); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSetCredentialResponseCallback + implements ChipClusters.DoorLockCluster.SetCredentialResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo nextCredentialIndexResponseValue = + new CommandResponseInfo("nextCredentialIndex", "Integer"); + responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedDoorLockClusterAttributeListAttributeCallback + implements ChipClusters.DoorLockCluster.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 DelegatedElectricalMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.ElectricalMeasurementCluster.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 DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.EthernetNetworkDiagnosticsCluster.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 DelegatedFixedLabelClusterLabelListAttributeCallback + implements ChipClusters.FixedLabelCluster.LabelListAttributeCallback, + 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 DelegatedFixedLabelClusterAttributeListAttributeCallback + implements ChipClusters.FixedLabelCluster.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 DelegatedFlowMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.FlowMeasurementCluster.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 DelegatedArmFailSafeResponseCallback + implements ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedCommissioningCompleteResponseCallback + implements ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSetRegulatoryConfigResponseCallback + implements ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static + class DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback + implements ChipClusters.GeneralCommissioningCluster + .BasicCommissioningInfoListAttributeCallback, + 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 DelegatedGeneralCommissioningClusterAttributeListAttributeCallback + implements ChipClusters.GeneralCommissioningCluster.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 DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.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 DelegatedKeySetReadAllIndicesResponseCallback + implements ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ArrayList groupKeySetIDs) { + Map responseValues = new LinkedHashMap<>(); + // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedKeySetReadResponseCallback + implements ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { + Map responseValues = new LinkedHashMap<>(); + // groupKeySet: Struct GroupKeySet + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback + implements ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback, + 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 DelegatedGroupKeyManagementClusterGroupTableAttributeCallback + implements ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback, + 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 DelegatedGroupKeyManagementClusterAttributeListAttributeCallback + implements ChipClusters.GroupKeyManagementCluster.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 DelegatedAddGroupResponseCallback + implements ChipClusters.GroupsCluster.AddGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetGroupMembershipResponseCallback + implements ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer capacity, ArrayList groupList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); + responseValues.put(capacityResponseValue, capacity); + // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveGroupResponseCallback + implements ChipClusters.GroupsCluster.RemoveGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedViewGroupResponseCallback + implements ChipClusters.GroupsCluster.ViewGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, String groupName) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo groupNameResponseValue = new CommandResponseInfo("groupName", "String"); + responseValues.put(groupNameResponseValue, groupName); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGroupsClusterAttributeListAttributeCallback + implements ChipClusters.GroupsCluster.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 DelegatedIdentifyQueryResponseCallback + implements ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer timeout) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo timeoutResponseValue = new CommandResponseInfo("timeout", "Integer"); + responseValues.put(timeoutResponseValue, timeout); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedIdentifyClusterAttributeListAttributeCallback + implements ChipClusters.IdentifyCluster.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 DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.IlluminanceMeasurementCluster.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 DelegatedSendKeyResponseCallback + implements ChipClusters.KeypadInputCluster.SendKeyResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedKeypadInputClusterAttributeListAttributeCallback + implements ChipClusters.KeypadInputCluster.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 DelegatedLevelControlClusterAttributeListAttributeCallback + implements ChipClusters.LevelControlCluster.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 DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback + implements ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback, + 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 DelegatedLowPowerClusterAttributeListAttributeCallback + implements ChipClusters.LowPowerCluster.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 DelegatedMediaInputClusterMediaInputListAttributeCallback + implements ChipClusters.MediaInputCluster.MediaInputListAttributeCallback, + 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 DelegatedMediaInputClusterAttributeListAttributeCallback + implements ChipClusters.MediaInputCluster.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 DelegatedPlaybackResponseCallback + implements ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedMediaPlaybackClusterAttributeListAttributeCallback + implements ChipClusters.MediaPlaybackCluster.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 DelegatedModeSelectClusterSupportedModesAttributeCallback + implements ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback, + 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 DelegatedModeSelectClusterAttributeListAttributeCallback + implements ChipClusters.ModeSelectCluster.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 DelegatedConnectNetworkResponseCallback + implements ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText, Long ErrorValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = + new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + CommandResponseInfo ErrorValueResponseValue = new CommandResponseInfo("ErrorValue", "Long"); + responseValues.put(ErrorValueResponseValue, ErrorValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNetworkConfigResponseCallback + implements ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = + new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedScanNetworksResponseCallback + implements ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer NetworkingStatus, + String DebugText, + Optional> + WiFiScanResults, + Optional> + ThreadScanResults) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = + new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + // WiFiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + // ThreadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNetworkCommissioningClusterNetworksAttributeCallback + implements ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback, + 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 DelegatedApplyUpdateResponseCallback + implements ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer action, Long delayedActionTime) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo actionResponseValue = new CommandResponseInfo("action", "Integer"); + responseValues.put(actionResponseValue, action); + CommandResponseInfo delayedActionTimeResponseValue = + new CommandResponseInfo("delayedActionTime", "Long"); + responseValues.put(delayedActionTimeResponseValue, delayedActionTime); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedQueryImageResponseCallback + implements ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, + Optional delayedActionTime, + Optional imageURI, + Optional softwareVersion, + Optional softwareVersionString, + Optional updateToken, + Optional userConsentNeeded, + Optional metadataForRequestor) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo delayedActionTimeResponseValue = + new CommandResponseInfo("delayedActionTime", "Optional"); + responseValues.put(delayedActionTimeResponseValue, delayedActionTime); + CommandResponseInfo imageURIResponseValue = + new CommandResponseInfo("imageURI", "Optional"); + responseValues.put(imageURIResponseValue, imageURI); + CommandResponseInfo softwareVersionResponseValue = + new CommandResponseInfo("softwareVersion", "Optional"); + responseValues.put(softwareVersionResponseValue, softwareVersion); + CommandResponseInfo softwareVersionStringResponseValue = + new CommandResponseInfo("softwareVersionString", "Optional"); + responseValues.put(softwareVersionStringResponseValue, softwareVersionString); + CommandResponseInfo updateTokenResponseValue = + new CommandResponseInfo("updateToken", "Optional"); + responseValues.put(updateTokenResponseValue, updateToken); + CommandResponseInfo userConsentNeededResponseValue = + new CommandResponseInfo("userConsentNeeded", "Optional"); + responseValues.put(userConsentNeededResponseValue, userConsentNeeded); + CommandResponseInfo metadataForRequestorResponseValue = + new CommandResponseInfo("metadataForRequestor", "Optional"); + responseValues.put(metadataForRequestorResponseValue, metadataForRequestor); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback + implements ChipClusters.OtaSoftwareUpdateProviderCluster.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 DelegatedOtaSoftwareUpdateRequestorClusterDefaultOtaProvidersAttributeCallback + implements ChipClusters.OtaSoftwareUpdateRequestorCluster + .DefaultOtaProvidersAttributeCallback, + 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 DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback + implements ChipClusters.OtaSoftwareUpdateRequestorCluster.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 DelegatedOccupancySensingClusterAttributeListAttributeCallback + implements ChipClusters.OccupancySensingCluster.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 DelegatedOnOffClusterAttributeListAttributeCallback + implements ChipClusters.OnOffCluster.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 DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback + implements ChipClusters.OnOffSwitchConfigurationCluster.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 DelegatedAttestationResponseCallback + implements ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] AttestationElements, byte[] Signature) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo AttestationElementsResponseValue = + new CommandResponseInfo("AttestationElements", "byte[]"); + responseValues.put(AttestationElementsResponseValue, AttestationElements); + CommandResponseInfo SignatureResponseValue = new CommandResponseInfo("Signature", "byte[]"); + responseValues.put(SignatureResponseValue, Signature); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedCertificateChainResponseCallback + implements ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] Certificate) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo CertificateResponseValue = + new CommandResponseInfo("Certificate", "byte[]"); + responseValues.put(CertificateResponseValue, Certificate); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNOCResponseCallback + implements ChipClusters.OperationalCredentialsCluster.NOCResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer StatusCode, Integer FabricIndex, String DebugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo StatusCodeResponseValue = + new CommandResponseInfo("StatusCode", "Integer"); + responseValues.put(StatusCodeResponseValue, StatusCode); + CommandResponseInfo FabricIndexResponseValue = + new CommandResponseInfo("FabricIndex", "Integer"); + responseValues.put(FabricIndexResponseValue, FabricIndex); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedOpCSRResponseCallback + implements ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] NOCSRElements, byte[] AttestationSignature) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NOCSRElementsResponseValue = + new CommandResponseInfo("NOCSRElements", "byte[]"); + responseValues.put(NOCSRElementsResponseValue, NOCSRElements); + CommandResponseInfo AttestationSignatureResponseValue = + new CommandResponseInfo("AttestationSignature", "byte[]"); + responseValues.put(AttestationSignatureResponseValue, AttestationSignature); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedOperationalCredentialsClusterNOCsAttributeCallback + implements ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback, + 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 DelegatedOperationalCredentialsClusterFabricsListAttributeCallback + implements ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback, + 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 DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback + implements ChipClusters.OperationalCredentialsCluster + .TrustedRootCertificatesAttributeCallback, + 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 DelegatedOperationalCredentialsClusterAttributeListAttributeCallback + implements ChipClusters.OperationalCredentialsCluster.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 DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback + implements ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback, + 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 DelegatedPowerSourceClusterAttributeListAttributeCallback + implements ChipClusters.PowerSourceCluster.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 DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback + implements ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback, + 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 DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback + implements ChipClusters.PowerSourceConfigurationCluster.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 DelegatedPressureMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.PressureMeasurementCluster.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 DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback + implements ChipClusters.PumpConfigurationAndControlCluster.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 DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.RelativeHumidityMeasurementCluster.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 DelegatedAddSceneResponseCallback + implements ChipClusters.ScenesCluster.AddSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetSceneMembershipResponseCallback + implements ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, + Integer capacity, + Integer groupId, + Integer sceneCount, + ArrayList sceneList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); + responseValues.put(capacityResponseValue, capacity); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneCountResponseValue = + new CommandResponseInfo("sceneCount", "Integer"); + responseValues.put(sceneCountResponseValue, sceneCount); + // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveAllScenesResponseCallback + implements ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveSceneResponseCallback + implements ChipClusters.ScenesCluster.RemoveSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedStoreSceneResponseCallback + implements ChipClusters.ScenesCluster.StoreSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedViewSceneResponseCallback + implements ChipClusters.ScenesCluster.ViewSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + CommandResponseInfo transitionTimeResponseValue = + new CommandResponseInfo("transitionTime", "Integer"); + responseValues.put(transitionTimeResponseValue, transitionTime); + CommandResponseInfo sceneNameResponseValue = new CommandResponseInfo("sceneName", "String"); + responseValues.put(sceneNameResponseValue, sceneName); + // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedScenesClusterAttributeListAttributeCallback + implements ChipClusters.ScenesCluster.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 DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback + implements ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback, + 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 DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.SoftwareDiagnosticsCluster.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 DelegatedSwitchClusterAttributeListAttributeCallback + implements ChipClusters.SwitchCluster.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 DelegatedNavigateTargetResponseCallback + implements ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback + implements ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback, + 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 DelegatedTargetNavigatorClusterAttributeListAttributeCallback + implements ChipClusters.TargetNavigatorCluster.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 DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.TemperatureMeasurementCluster.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 DelegatedBooleanResponseCallback + implements ChipClusters.TestClusterCluster.BooleanResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Boolean value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Boolean"); + responseValues.put(valueResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSimpleStructResponseCallback + implements ChipClusters.TestClusterCluster.SimpleStructResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1) { + Map responseValues = new LinkedHashMap<>(); + // arg1: Struct SimpleStruct + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestAddArgumentsResponseCallback + implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer returnValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo returnValueResponseValue = + new CommandResponseInfo("returnValue", "Integer"); + responseValues.put(returnValueResponseValue, returnValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestEmitTestEventResponseCallback + implements ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Long value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Long"); + responseValues.put(valueResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestEnumsResponseCallback + implements ChipClusters.TestClusterCluster.TestEnumsResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer arg1, Integer arg2) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo arg1ResponseValue = new CommandResponseInfo("arg1", "Integer"); + responseValues.put(arg1ResponseValue, arg1); + CommandResponseInfo arg2ResponseValue = new CommandResponseInfo("arg2", "Integer"); + responseValues.put(arg2ResponseValue, arg2); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestListInt8UReverseResponseCallback + implements ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ArrayList arg1) { + Map responseValues = new LinkedHashMap<>(); + // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestNullableOptionalResponseCallback + implements ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Boolean wasPresent, + Optional wasNull, + Optional value, + @Nullable Optional originalValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo wasPresentResponseValue = + new CommandResponseInfo("wasPresent", "Boolean"); + responseValues.put(wasPresentResponseValue, wasPresent); + CommandResponseInfo wasNullResponseValue = + new CommandResponseInfo("wasNull", "Optional"); + responseValues.put(wasNullResponseValue, wasNull); + CommandResponseInfo valueResponseValue = + new CommandResponseInfo("value", "Optional"); + responseValues.put(valueResponseValue, value); + CommandResponseInfo originalValueResponseValue = + new CommandResponseInfo("originalValue", "Optional"); + responseValues.put(originalValueResponseValue, originalValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestSpecificResponseCallback + implements ChipClusters.TestClusterCluster.TestSpecificResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer returnValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo returnValueResponseValue = + new CommandResponseInfo("returnValue", "Integer"); + responseValues.put(returnValueResponseValue, returnValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestClusterClusterListInt8uAttributeCallback + implements ChipClusters.TestClusterCluster.ListInt8uAttributeCallback, + 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 DelegatedTestClusterClusterListOctetStringAttributeCallback + implements ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback, + 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 DelegatedTestClusterClusterListStructOctetStringAttributeCallback + implements ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback, + 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 DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback + implements ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback, + 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 DelegatedTestClusterClusterListLongOctetStringAttributeCallback + implements ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback, + 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 DelegatedTestClusterClusterAttributeListAttributeCallback + implements ChipClusters.TestClusterCluster.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 DelegatedGetRelayStatusLogResponseCallback + implements ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer timeOfDay, + Integer relayStatus, + Integer localTemperature, + Integer humidityInPercentage, + Integer setpoint, + Integer unreadEntries) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo timeOfDayResponseValue = new CommandResponseInfo("timeOfDay", "Integer"); + responseValues.put(timeOfDayResponseValue, timeOfDay); + CommandResponseInfo relayStatusResponseValue = + new CommandResponseInfo("relayStatus", "Integer"); + responseValues.put(relayStatusResponseValue, relayStatus); + CommandResponseInfo localTemperatureResponseValue = + new CommandResponseInfo("localTemperature", "Integer"); + responseValues.put(localTemperatureResponseValue, localTemperature); + CommandResponseInfo humidityInPercentageResponseValue = + new CommandResponseInfo("humidityInPercentage", "Integer"); + responseValues.put(humidityInPercentageResponseValue, humidityInPercentage); + CommandResponseInfo setpointResponseValue = new CommandResponseInfo("setpoint", "Integer"); + responseValues.put(setpointResponseValue, setpoint); + CommandResponseInfo unreadEntriesResponseValue = + new CommandResponseInfo("unreadEntries", "Integer"); + responseValues.put(unreadEntriesResponseValue, unreadEntries); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetWeeklyScheduleResponseCallback + implements ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo numberOfTransitionsForSequenceResponseValue = + new CommandResponseInfo("numberOfTransitionsForSequence", "Integer"); + responseValues.put( + numberOfTransitionsForSequenceResponseValue, numberOfTransitionsForSequence); + CommandResponseInfo dayOfWeekForSequenceResponseValue = + new CommandResponseInfo("dayOfWeekForSequence", "Integer"); + responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); + CommandResponseInfo modeForSequenceResponseValue = + new CommandResponseInfo("modeForSequence", "Integer"); + responseValues.put(modeForSequenceResponseValue, modeForSequence); + // payload: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedThermostatClusterAttributeListAttributeCallback + implements ChipClusters.ThermostatCluster.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 DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback + implements ChipClusters.ThermostatUserInterfaceConfigurationCluster + .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 DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster + .OperationalDatasetComponentsAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster + .ActiveNetworkFaultsListAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.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 DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback + implements ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback, + 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 DelegatedUserLabelClusterLabelListAttributeCallback + implements ChipClusters.UserLabelCluster.LabelListAttributeCallback, + 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 DelegatedWakeOnLanClusterAttributeListAttributeCallback + implements ChipClusters.WakeOnLanCluster.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 DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.WiFiNetworkDiagnosticsCluster.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 DelegatedWindowCoveringClusterAttributeListAttributeCallback + implements ChipClusters.WindowCoveringCluster.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 Map getClusterMap() { + Map clusterMap = initializeClusterMap(); + Map> commandMap = getCommandMap(); + combineCommand(clusterMap, commandMap); + Map> readAttributeMap = + new ClusterReadMapping().getReadAttributeMap(); + combineCommand(clusterMap, readAttributeMap); + Map> writeAttributeMap = + new ClusterWriteMapping().getWriteAttributeMap(); + combineCommand(clusterMap, writeAttributeMap); + return clusterMap; + } + + public Map initializeClusterMap() { + Map clusterMap = new HashMap<>(); + ClusterInfo accessControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AccessControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("accessControl", accessControlClusterInfo); + ClusterInfo accountLoginClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("accountLogin", accountLoginClusterInfo); + ClusterInfo administratorCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); + ClusterInfo applicationBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("applicationBasic", applicationBasicClusterInfo); + ClusterInfo applicationLauncherClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); + ClusterInfo audioOutputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("audioOutput", audioOutputClusterInfo); + ClusterInfo barrierControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("barrierControl", barrierControlClusterInfo); + ClusterInfo basicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("basic", basicClusterInfo); + ClusterInfo binaryInputBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); + ClusterInfo bindingClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("binding", bindingClusterInfo); + ClusterInfo booleanStateClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("booleanState", booleanStateClusterInfo); + ClusterInfo bridgedActionsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("bridgedActions", bridgedActionsClusterInfo); + ClusterInfo bridgedDeviceBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); + ClusterInfo channelClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ChannelCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("channel", channelClusterInfo); + ClusterInfo colorControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("colorControl", colorControlClusterInfo); + ClusterInfo contentLauncherClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("contentLauncher", contentLauncherClusterInfo); + ClusterInfo descriptorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("descriptor", descriptorClusterInfo); + ClusterInfo diagnosticLogsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); + ClusterInfo doorLockClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("doorLock", doorLockClusterInfo); + ClusterInfo electricalMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); + ClusterInfo ethernetNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); + ClusterInfo fixedLabelClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("fixedLabel", fixedLabelClusterInfo); + ClusterInfo flowMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); + ClusterInfo generalCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); + ClusterInfo generalDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); + ClusterInfo groupKeyManagementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); + ClusterInfo groupsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("groups", groupsClusterInfo); + ClusterInfo identifyClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("identify", identifyClusterInfo); + ClusterInfo illuminanceMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); + ClusterInfo keypadInputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("keypadInput", keypadInputClusterInfo); + ClusterInfo levelControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("levelControl", levelControlClusterInfo); + ClusterInfo localizationConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LocalizationConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("localizationConfiguration", localizationConfigurationClusterInfo); + ClusterInfo lowPowerClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("lowPower", lowPowerClusterInfo); + ClusterInfo mediaInputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("mediaInput", mediaInputClusterInfo); + ClusterInfo mediaPlaybackClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); + ClusterInfo modeSelectClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("modeSelect", modeSelectClusterInfo); + ClusterInfo networkCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); + ClusterInfo otaSoftwareUpdateProviderClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); + ClusterInfo otaSoftwareUpdateRequestorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); + ClusterInfo occupancySensingClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("occupancySensing", occupancySensingClusterInfo); + ClusterInfo onOffClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("onOff", onOffClusterInfo); + ClusterInfo onOffSwitchConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); + ClusterInfo operationalCredentialsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); + ClusterInfo powerSourceClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("powerSource", powerSourceClusterInfo); + ClusterInfo powerSourceConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PowerSourceConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInfo); + ClusterInfo pressureMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); + ClusterInfo pumpConfigurationAndControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); + ClusterInfo relativeHumidityMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); + ClusterInfo scenesClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("scenes", scenesClusterInfo); + ClusterInfo softwareDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); + ClusterInfo switchClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("switch", switchClusterInfo); + ClusterInfo targetNavigatorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("targetNavigator", targetNavigatorClusterInfo); + ClusterInfo temperatureMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); + ClusterInfo testClusterClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("testCluster", testClusterClusterInfo); + ClusterInfo thermostatClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("thermostat", thermostatClusterInfo); + ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put( + "thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); + ClusterInfo threadNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); + ClusterInfo timeFormatLocalizationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TimeFormatLocalizationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("timeFormatLocalization", timeFormatLocalizationClusterInfo); + ClusterInfo unitLocalizationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.UnitLocalizationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("unitLocalization", unitLocalizationClusterInfo); + ClusterInfo userLabelClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.UserLabelCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("userLabel", userLabelClusterInfo); + ClusterInfo wakeOnLanClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); + ClusterInfo wiFiNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); + ClusterInfo windowCoveringClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("windowCovering", windowCoveringClusterInfo); + return clusterMap; + } + + public void combineCommand( + Map destination, Map> source) { + destination.get("accessControl").combineCommands(source.get("accessControl")); + destination.get("accountLogin").combineCommands(source.get("accountLogin")); + destination + .get("administratorCommissioning") + .combineCommands(source.get("administratorCommissioning")); + destination.get("applicationBasic").combineCommands(source.get("applicationBasic")); + destination.get("applicationLauncher").combineCommands(source.get("applicationLauncher")); + destination.get("audioOutput").combineCommands(source.get("audioOutput")); + destination.get("barrierControl").combineCommands(source.get("barrierControl")); + destination.get("basic").combineCommands(source.get("basic")); + destination.get("binaryInputBasic").combineCommands(source.get("binaryInputBasic")); + destination.get("binding").combineCommands(source.get("binding")); + destination.get("booleanState").combineCommands(source.get("booleanState")); + destination.get("bridgedActions").combineCommands(source.get("bridgedActions")); + destination.get("bridgedDeviceBasic").combineCommands(source.get("bridgedDeviceBasic")); + destination.get("channel").combineCommands(source.get("channel")); + destination.get("colorControl").combineCommands(source.get("colorControl")); + destination.get("contentLauncher").combineCommands(source.get("contentLauncher")); + destination.get("descriptor").combineCommands(source.get("descriptor")); + destination.get("diagnosticLogs").combineCommands(source.get("diagnosticLogs")); + destination.get("doorLock").combineCommands(source.get("doorLock")); + destination.get("electricalMeasurement").combineCommands(source.get("electricalMeasurement")); + destination + .get("ethernetNetworkDiagnostics") + .combineCommands(source.get("ethernetNetworkDiagnostics")); + destination.get("fixedLabel").combineCommands(source.get("fixedLabel")); + destination.get("flowMeasurement").combineCommands(source.get("flowMeasurement")); + destination.get("generalCommissioning").combineCommands(source.get("generalCommissioning")); + destination.get("generalDiagnostics").combineCommands(source.get("generalDiagnostics")); + destination.get("groupKeyManagement").combineCommands(source.get("groupKeyManagement")); + destination.get("groups").combineCommands(source.get("groups")); + destination.get("identify").combineCommands(source.get("identify")); + destination.get("illuminanceMeasurement").combineCommands(source.get("illuminanceMeasurement")); + destination.get("keypadInput").combineCommands(source.get("keypadInput")); + destination.get("levelControl").combineCommands(source.get("levelControl")); + destination + .get("localizationConfiguration") + .combineCommands(source.get("localizationConfiguration")); + destination.get("lowPower").combineCommands(source.get("lowPower")); + destination.get("mediaInput").combineCommands(source.get("mediaInput")); + destination.get("mediaPlayback").combineCommands(source.get("mediaPlayback")); + destination.get("modeSelect").combineCommands(source.get("modeSelect")); + destination.get("networkCommissioning").combineCommands(source.get("networkCommissioning")); + destination + .get("otaSoftwareUpdateProvider") + .combineCommands(source.get("otaSoftwareUpdateProvider")); + destination + .get("otaSoftwareUpdateRequestor") + .combineCommands(source.get("otaSoftwareUpdateRequestor")); + destination.get("occupancySensing").combineCommands(source.get("occupancySensing")); + destination.get("onOff").combineCommands(source.get("onOff")); + destination + .get("onOffSwitchConfiguration") + .combineCommands(source.get("onOffSwitchConfiguration")); + destination.get("operationalCredentials").combineCommands(source.get("operationalCredentials")); + destination.get("powerSource").combineCommands(source.get("powerSource")); + destination + .get("powerSourceConfiguration") + .combineCommands(source.get("powerSourceConfiguration")); + destination.get("pressureMeasurement").combineCommands(source.get("pressureMeasurement")); + destination + .get("pumpConfigurationAndControl") + .combineCommands(source.get("pumpConfigurationAndControl")); + destination + .get("relativeHumidityMeasurement") + .combineCommands(source.get("relativeHumidityMeasurement")); + destination.get("scenes").combineCommands(source.get("scenes")); + destination.get("softwareDiagnostics").combineCommands(source.get("softwareDiagnostics")); + destination.get("switch").combineCommands(source.get("switch")); + destination.get("targetNavigator").combineCommands(source.get("targetNavigator")); + destination.get("temperatureMeasurement").combineCommands(source.get("temperatureMeasurement")); + destination.get("testCluster").combineCommands(source.get("testCluster")); + destination.get("thermostat").combineCommands(source.get("thermostat")); + destination + .get("thermostatUserInterfaceConfiguration") + .combineCommands(source.get("thermostatUserInterfaceConfiguration")); + destination + .get("threadNetworkDiagnostics") + .combineCommands(source.get("threadNetworkDiagnostics")); + destination.get("timeFormatLocalization").combineCommands(source.get("timeFormatLocalization")); + destination.get("unitLocalization").combineCommands(source.get("unitLocalization")); + destination.get("userLabel").combineCommands(source.get("userLabel")); + destination.get("wakeOnLan").combineCommands(source.get("wakeOnLan")); + destination.get("wiFiNetworkDiagnostics").combineCommands(source.get("wiFiNetworkDiagnostics")); + destination.get("windowCovering").combineCommands(source.get("windowCovering")); + } + + @SuppressWarnings("unchecked") + public Map> getCommandMap() { + Map> commandMap = new HashMap<>(); + Map accessControlClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("accessControl", accessControlClusterInteractionInfoMap); + Map accountLoginClusterInteractionInfoMap = new LinkedHashMap<>(); + Map accountLogingetSetupPINRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = + new CommandParameterInfo("tempAccountIdentifier", String.class); + accountLogingetSetupPINRequestCommandParams.put( + "tempAccountIdentifier", + accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); + + InteractionInfo accountLogingetSetupPINRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .getSetupPINRequest( + (ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback) callback, + (String) commandArguments.get("tempAccountIdentifier"), + 10000); + }, + () -> new DelegatedGetSetupPINResponseCallback(), + accountLogingetSetupPINRequestCommandParams); + accountLoginClusterInteractionInfoMap.put( + "getSetupPINRequest", accountLogingetSetupPINRequestInteractionInfo); + Map accountLoginloginRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = + new CommandParameterInfo("tempAccountIdentifier", String.class); + accountLoginloginRequestCommandParams.put( + "tempAccountIdentifier", accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); + + CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = + new CommandParameterInfo("setupPIN", String.class); + accountLoginloginRequestCommandParams.put( + "setupPIN", accountLoginloginRequestsetupPINCommandParameterInfo); + + InteractionInfo accountLoginloginRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .loginRequest( + (DefaultClusterCallback) callback, + (String) commandArguments.get("tempAccountIdentifier"), + (String) commandArguments.get("setupPIN"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + accountLoginloginRequestCommandParams); + accountLoginClusterInteractionInfoMap.put( + "loginRequest", accountLoginloginRequestInteractionInfo); + Map accountLoginlogoutRequestCommandParams = + new LinkedHashMap(); + InteractionInfo accountLoginlogoutRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .logoutRequest((DefaultClusterCallback) callback, 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + accountLoginlogoutRequestCommandParams); + accountLoginClusterInteractionInfoMap.put( + "logoutRequest", accountLoginlogoutRequestInteractionInfo); + commandMap.put("accountLogin", accountLoginClusterInteractionInfoMap); + Map administratorCommissioningClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map + administratorCommissioningopenBasicCommissioningWindowCommandParams = + new LinkedHashMap(); + CommandParameterInfo + administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = + new CommandParameterInfo("commissioningTimeout", Integer.class); + administratorCommissioningopenBasicCommissioningWindowCommandParams.put( + "commissioningTimeout", + administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); + + InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .openBasicCommissioningWindow( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("commissioningTimeout"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningopenBasicCommissioningWindowCommandParams); + administratorCommissioningClusterInteractionInfoMap.put( + "openBasicCommissioningWindow", + administratorCommissioningopenBasicCommissioningWindowInteractionInfo); + Map + administratorCommissioningopenCommissioningWindowCommandParams = + new LinkedHashMap(); + CommandParameterInfo + administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = + new CommandParameterInfo("commissioningTimeout", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "commissioningTimeout", + administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = + new CommandParameterInfo("PAKEVerifier", byte[].class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "PAKEVerifier", + administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = + new CommandParameterInfo("discriminator", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "discriminator", + administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = + new CommandParameterInfo("iterations", Long.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "iterations", + administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = + new CommandParameterInfo("salt", byte[].class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "salt", administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = + new CommandParameterInfo("passcodeID", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "passcodeID", + administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); + + InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .openCommissioningWindow( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("commissioningTimeout"), + (byte[]) commandArguments.get("PAKEVerifier"), + (Integer) commandArguments.get("discriminator"), + (Long) commandArguments.get("iterations"), + (byte[]) commandArguments.get("salt"), + (Integer) commandArguments.get("passcodeID"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningopenCommissioningWindowCommandParams); + administratorCommissioningClusterInteractionInfoMap.put( + "openCommissioningWindow", + administratorCommissioningopenCommissioningWindowInteractionInfo); + Map administratorCommissioningrevokeCommissioningCommandParams = + new LinkedHashMap(); + InteractionInfo administratorCommissioningrevokeCommissioningInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .revokeCommissioning((DefaultClusterCallback) callback, 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningrevokeCommissioningCommandParams); + administratorCommissioningClusterInteractionInfoMap.put( + "revokeCommissioning", administratorCommissioningrevokeCommissioningInteractionInfo); + commandMap.put( + "administratorCommissioning", administratorCommissioningClusterInteractionInfoMap); + Map applicationBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("applicationBasic", applicationBasicClusterInteractionInfoMap); + Map applicationLauncherClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map applicationLauncherhideAppRequestCommandParams = + new LinkedHashMap(); + InteractionInfo applicationLauncherhideAppRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .hideAppRequest( + (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, + (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application")); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherhideAppRequestCommandParams); + applicationLauncherClusterInteractionInfoMap.put( + "hideAppRequest", applicationLauncherhideAppRequestInteractionInfo); + Map applicationLauncherlaunchAppRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = + new CommandParameterInfo("data", String.class); + applicationLauncherlaunchAppRequestCommandParams.put( + "data", applicationLauncherlaunchAppRequestdataCommandParameterInfo); + + InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .launchAppRequest( + (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, + (String) commandArguments.get("data"), + (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application")); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherlaunchAppRequestCommandParams); + applicationLauncherClusterInteractionInfoMap.put( + "launchAppRequest", applicationLauncherlaunchAppRequestInteractionInfo); + Map applicationLauncherstopAppRequestCommandParams = + new LinkedHashMap(); + InteractionInfo applicationLauncherstopAppRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .stopAppRequest( + (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, + (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application")); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherstopAppRequestCommandParams); + applicationLauncherClusterInteractionInfoMap.put( + "stopAppRequest", applicationLauncherstopAppRequestInteractionInfo); + commandMap.put("applicationLauncher", applicationLauncherClusterInteractionInfoMap); + Map audioOutputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map audioOutputrenameOutputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + audioOutputrenameOutputRequestCommandParams.put( + "index", audioOutputrenameOutputRequestindexCommandParameterInfo); + + CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = + new CommandParameterInfo("name", String.class); + audioOutputrenameOutputRequestCommandParams.put( + "name", audioOutputrenameOutputRequestnameCommandParameterInfo); + + InteractionInfo audioOutputrenameOutputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .renameOutputRequest( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("index"), + (String) commandArguments.get("name")); + }, + () -> new DelegatedDefaultClusterCallback(), + audioOutputrenameOutputRequestCommandParams); + audioOutputClusterInteractionInfoMap.put( + "renameOutputRequest", audioOutputrenameOutputRequestInteractionInfo); + Map audioOutputselectOutputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + audioOutputselectOutputRequestCommandParams.put( + "index", audioOutputselectOutputRequestindexCommandParameterInfo); + + InteractionInfo audioOutputselectOutputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .selectOutputRequest( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("index")); + }, + () -> new DelegatedDefaultClusterCallback(), + audioOutputselectOutputRequestCommandParams); + audioOutputClusterInteractionInfoMap.put( + "selectOutputRequest", audioOutputselectOutputRequestInteractionInfo); + commandMap.put("audioOutput", audioOutputClusterInteractionInfoMap); + Map barrierControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map barrierControlbarrierControlGoToPercentCommandParams = + new LinkedHashMap(); + CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = + new CommandParameterInfo("percentOpen", Integer.class); + barrierControlbarrierControlGoToPercentCommandParams.put( + "percentOpen", barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); + + InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .barrierControlGoToPercent( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("percentOpen")); + }, + () -> new DelegatedDefaultClusterCallback(), + barrierControlbarrierControlGoToPercentCommandParams); + barrierControlClusterInteractionInfoMap.put( + "barrierControlGoToPercent", barrierControlbarrierControlGoToPercentInteractionInfo); + Map barrierControlbarrierControlStopCommandParams = + new LinkedHashMap(); + InteractionInfo barrierControlbarrierControlStopInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .barrierControlStop((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + barrierControlbarrierControlStopCommandParams); + barrierControlClusterInteractionInfoMap.put( + "barrierControlStop", barrierControlbarrierControlStopInteractionInfo); + commandMap.put("barrierControl", barrierControlClusterInteractionInfoMap); + Map basicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("basic", basicClusterInteractionInfoMap); + Map binaryInputBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("binaryInputBasic", binaryInputBasicClusterInteractionInfoMap); + Map bindingClusterInteractionInfoMap = new LinkedHashMap<>(); + Map bindingbindCommandParams = + new LinkedHashMap(); + CommandParameterInfo bindingbindnodeIdCommandParameterInfo = + new CommandParameterInfo("nodeId", Long.class); + bindingbindCommandParams.put("nodeId", bindingbindnodeIdCommandParameterInfo); + + CommandParameterInfo bindingbindgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + bindingbindCommandParams.put("groupId", bindingbindgroupIdCommandParameterInfo); + + CommandParameterInfo bindingbindendpointIdCommandParameterInfo = + new CommandParameterInfo("endpointId", Integer.class); + bindingbindCommandParams.put("endpointId", bindingbindendpointIdCommandParameterInfo); + + CommandParameterInfo bindingbindclusterIdCommandParameterInfo = + new CommandParameterInfo("clusterId", Long.class); + bindingbindCommandParams.put("clusterId", bindingbindclusterIdCommandParameterInfo); + + InteractionInfo bindingbindInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .bind( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("nodeId"), + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("endpointId"), + (Long) commandArguments.get("clusterId")); + }, + () -> new DelegatedDefaultClusterCallback(), + bindingbindCommandParams); + bindingClusterInteractionInfoMap.put("bind", bindingbindInteractionInfo); + Map bindingunbindCommandParams = + new LinkedHashMap(); + CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = + new CommandParameterInfo("nodeId", Long.class); + bindingunbindCommandParams.put("nodeId", bindingunbindnodeIdCommandParameterInfo); + + CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + bindingunbindCommandParams.put("groupId", bindingunbindgroupIdCommandParameterInfo); + + CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = + new CommandParameterInfo("endpointId", Integer.class); + bindingunbindCommandParams.put("endpointId", bindingunbindendpointIdCommandParameterInfo); + + CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = + new CommandParameterInfo("clusterId", Long.class); + bindingunbindCommandParams.put("clusterId", bindingunbindclusterIdCommandParameterInfo); + + InteractionInfo bindingunbindInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .unbind( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("nodeId"), + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("endpointId"), + (Long) commandArguments.get("clusterId")); + }, + () -> new DelegatedDefaultClusterCallback(), + bindingunbindCommandParams); + bindingClusterInteractionInfoMap.put("unbind", bindingunbindInteractionInfo); + commandMap.put("binding", bindingClusterInteractionInfoMap); + Map booleanStateClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("booleanState", booleanStateClusterInteractionInfoMap); + Map bridgedActionsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map bridgedActionsdisableActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsdisableActionCommandParams.put( + "actionID", bridgedActionsdisableActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsdisableActionCommandParams.put( + "invokeID", bridgedActionsdisableActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsdisableActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .disableAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsdisableActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "disableAction", bridgedActionsdisableActionInteractionInfo); + Map bridgedActionsdisableActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsdisableActionWithDurationCommandParams.put( + "actionID", bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsdisableActionWithDurationCommandParams.put( + "invokeID", bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionsdisableActionWithDurationCommandParams.put( + "duration", bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .disableActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsdisableActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "disableActionWithDuration", bridgedActionsdisableActionWithDurationInteractionInfo); + Map bridgedActionsenableActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsenableActionCommandParams.put( + "actionID", bridgedActionsenableActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsenableActionCommandParams.put( + "invokeID", bridgedActionsenableActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsenableActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .enableAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsenableActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "enableAction", bridgedActionsenableActionInteractionInfo); + Map bridgedActionsenableActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsenableActionWithDurationCommandParams.put( + "actionID", bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsenableActionWithDurationCommandParams.put( + "invokeID", bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionsenableActionWithDurationCommandParams.put( + "duration", bridgedActionsenableActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .enableActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsenableActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "enableActionWithDuration", bridgedActionsenableActionWithDurationInteractionInfo); + Map bridgedActionsinstantActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsinstantActionCommandParams.put( + "actionID", bridgedActionsinstantActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsinstantActionCommandParams.put( + "invokeID", bridgedActionsinstantActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsinstantActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .instantAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsinstantActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "instantAction", bridgedActionsinstantActionInteractionInfo); + Map bridgedActionsinstantActionWithTransitionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsinstantActionWithTransitionCommandParams.put( + "actionID", bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsinstantActionWithTransitionCommandParams.put( + "invokeID", bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); + + CommandParameterInfo + bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + bridgedActionsinstantActionWithTransitionCommandParams.put( + "transitionTime", + bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); + + InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .instantActionWithTransition( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsinstantActionWithTransitionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "instantActionWithTransition", bridgedActionsinstantActionWithTransitionInteractionInfo); + Map bridgedActionspauseActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionspauseActionCommandParams.put( + "actionID", bridgedActionspauseActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionspauseActionCommandParams.put( + "invokeID", bridgedActionspauseActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionspauseActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .pauseAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionspauseActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "pauseAction", bridgedActionspauseActionInteractionInfo); + Map bridgedActionspauseActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionspauseActionWithDurationCommandParams.put( + "actionID", bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionspauseActionWithDurationCommandParams.put( + "invokeID", bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionspauseActionWithDurationCommandParams.put( + "duration", bridgedActionspauseActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .pauseActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionspauseActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "pauseActionWithDuration", bridgedActionspauseActionWithDurationInteractionInfo); + Map bridgedActionsresumeActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsresumeActionCommandParams.put( + "actionID", bridgedActionsresumeActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsresumeActionCommandParams.put( + "invokeID", bridgedActionsresumeActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsresumeActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .resumeAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsresumeActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "resumeAction", bridgedActionsresumeActionInteractionInfo); + Map bridgedActionsstartActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstartActionCommandParams.put( + "actionID", bridgedActionsstartActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstartActionCommandParams.put( + "invokeID", bridgedActionsstartActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsstartActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .startAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstartActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "startAction", bridgedActionsstartActionInteractionInfo); + Map bridgedActionsstartActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstartActionWithDurationCommandParams.put( + "actionID", bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstartActionWithDurationCommandParams.put( + "invokeID", bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionsstartActionWithDurationCommandParams.put( + "duration", bridgedActionsstartActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .startActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstartActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "startActionWithDuration", bridgedActionsstartActionWithDurationInteractionInfo); + Map bridgedActionsstopActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstopActionCommandParams.put( + "actionID", bridgedActionsstopActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstopActionCommandParams.put( + "invokeID", bridgedActionsstopActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsstopActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .stopAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstopActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "stopAction", bridgedActionsstopActionInteractionInfo); + commandMap.put("bridgedActions", bridgedActionsClusterInteractionInfoMap); + Map bridgedDeviceBasicClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInteractionInfoMap); + Map channelClusterInteractionInfoMap = new LinkedHashMap<>(); + Map channelchangeChannelByNumberRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = + new CommandParameterInfo("majorNumber", Integer.class); + channelchangeChannelByNumberRequestCommandParams.put( + "majorNumber", channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); + + CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = + new CommandParameterInfo("minorNumber", Integer.class); + channelchangeChannelByNumberRequestCommandParams.put( + "minorNumber", channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); + + InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .changeChannelByNumberRequest( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("majorNumber"), + (Integer) commandArguments.get("minorNumber")); + }, + () -> new DelegatedDefaultClusterCallback(), + channelchangeChannelByNumberRequestCommandParams); + channelClusterInteractionInfoMap.put( + "changeChannelByNumberRequest", channelchangeChannelByNumberRequestInteractionInfo); + Map channelchangeChannelRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = + new CommandParameterInfo("match", String.class); + channelchangeChannelRequestCommandParams.put( + "match", channelchangeChannelRequestmatchCommandParameterInfo); + + InteractionInfo channelchangeChannelRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .changeChannelRequest( + (ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback, + (String) commandArguments.get("match")); + }, + () -> new DelegatedChangeChannelResponseCallback(), + channelchangeChannelRequestCommandParams); + channelClusterInteractionInfoMap.put( + "changeChannelRequest", channelchangeChannelRequestInteractionInfo); + Map channelskipChannelRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = + new CommandParameterInfo("count", Integer.class); + channelskipChannelRequestCommandParams.put( + "count", channelskipChannelRequestcountCommandParameterInfo); + + InteractionInfo channelskipChannelRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .skipChannelRequest( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("count")); + }, + () -> new DelegatedDefaultClusterCallback(), + channelskipChannelRequestCommandParams); + channelClusterInteractionInfoMap.put( + "skipChannelRequest", channelskipChannelRequestInteractionInfo); + commandMap.put("channel", channelClusterInteractionInfoMap); + Map colorControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map colorControlcolorLoopSetCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = + new CommandParameterInfo("updateFlags", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "updateFlags", colorControlcolorLoopSetupdateFlagsCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = + new CommandParameterInfo("action", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "action", colorControlcolorLoopSetactionCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = + new CommandParameterInfo("direction", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "direction", colorControlcolorLoopSetdirectionCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = + new CommandParameterInfo("time", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "time", colorControlcolorLoopSettimeCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = + new CommandParameterInfo("startHue", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "startHue", colorControlcolorLoopSetstartHueCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "optionsMask", colorControlcolorLoopSetoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "optionsOverride", colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlcolorLoopSetInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .colorLoopSet( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("updateFlags"), + (Integer) commandArguments.get("action"), + (Integer) commandArguments.get("direction"), + (Integer) commandArguments.get("time"), + (Integer) commandArguments.get("startHue"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlcolorLoopSetCommandParams); + colorControlClusterInteractionInfoMap.put( + "colorLoopSet", colorControlcolorLoopSetInteractionInfo); + Map colorControlenhancedMoveHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "moveMode", colorControlenhancedMoveHuemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "rate", colorControlenhancedMoveHuerateCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "optionsMask", colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "optionsOverride", colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveHueCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveHue", colorControlenhancedMoveHueInteractionInfo); + Map colorControlenhancedMoveToHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = + new CommandParameterInfo("enhancedHue", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "enhancedHue", colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = + new CommandParameterInfo("direction", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "direction", colorControlenhancedMoveToHuedirectionCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "transitionTime", colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "optionsMask", colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "optionsOverride", colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveToHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveToHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("enhancedHue"), + (Integer) commandArguments.get("direction"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveToHueCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveToHue", colorControlenhancedMoveToHueInteractionInfo); + Map colorControlenhancedMoveToHueAndSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = + new CommandParameterInfo("enhancedHue", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "enhancedHue", colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = + new CommandParameterInfo("saturation", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "saturation", colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); + + CommandParameterInfo + colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "transitionTime", + colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "optionsMask", colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo + colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "optionsOverride", + colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveToHueAndSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("enhancedHue"), + (Integer) commandArguments.get("saturation"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveToHueAndSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveToHueAndSaturation", + colorControlenhancedMoveToHueAndSaturationInteractionInfo); + Map colorControlenhancedStepHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "stepMode", colorControlenhancedStepHuestepModeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "stepSize", colorControlenhancedStepHuestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "transitionTime", colorControlenhancedStepHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "optionsMask", colorControlenhancedStepHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "optionsOverride", colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedStepHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedStepHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedStepHueCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedStepHue", colorControlenhancedStepHueInteractionInfo); + Map colorControlmoveColorCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = + new CommandParameterInfo("rateX", Integer.class); + colorControlmoveColorCommandParams.put("rateX", colorControlmoveColorrateXCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = + new CommandParameterInfo("rateY", Integer.class); + colorControlmoveColorCommandParams.put("rateY", colorControlmoveColorrateYCommandParameterInfo); + + CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveColorCommandParams.put( + "optionsMask", colorControlmoveColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveColorCommandParams.put( + "optionsOverride", colorControlmoveColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveColorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveColor( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("rateX"), + (Integer) commandArguments.get("rateY"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveColorCommandParams); + colorControlClusterInteractionInfoMap.put("moveColor", colorControlmoveColorInteractionInfo); + Map colorControlmoveColorTemperatureCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "moveMode", colorControlmoveColorTemperaturemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "rate", colorControlmoveColorTemperaturerateCommandParameterInfo); + + CommandParameterInfo + colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMinimum", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "colorTemperatureMinimum", + colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); + + CommandParameterInfo + colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMaximum", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "colorTemperatureMaximum", + colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "optionsMask", colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "optionsOverride", colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveColorTemperatureInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveColorTemperature( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("colorTemperatureMinimum"), + (Integer) commandArguments.get("colorTemperatureMaximum"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveColorTemperatureCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveColorTemperature", colorControlmoveColorTemperatureInteractionInfo); + Map colorControlmoveHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveHueCommandParams.put( + "moveMode", colorControlmoveHuemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlmoveHueCommandParams.put("rate", colorControlmoveHuerateCommandParameterInfo); + + CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveHueCommandParams.put( + "optionsMask", colorControlmoveHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveHueCommandParams.put( + "optionsOverride", colorControlmoveHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveHueCommandParams); + colorControlClusterInteractionInfoMap.put("moveHue", colorControlmoveHueInteractionInfo); + Map colorControlmoveSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveSaturationCommandParams.put( + "moveMode", colorControlmoveSaturationmoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlmoveSaturationCommandParams.put( + "rate", colorControlmoveSaturationrateCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveSaturationCommandParams.put( + "optionsMask", colorControlmoveSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveSaturationCommandParams.put( + "optionsOverride", colorControlmoveSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveSaturation", colorControlmoveSaturationInteractionInfo); + Map colorControlmoveToColorCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = + new CommandParameterInfo("colorX", Integer.class); + colorControlmoveToColorCommandParams.put( + "colorX", colorControlmoveToColorcolorXCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = + new CommandParameterInfo("colorY", Integer.class); + colorControlmoveToColorCommandParams.put( + "colorY", colorControlmoveToColorcolorYCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToColorCommandParams.put( + "transitionTime", colorControlmoveToColortransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToColorCommandParams.put( + "optionsMask", colorControlmoveToColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToColorCommandParams.put( + "optionsOverride", colorControlmoveToColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToColorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToColor( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("colorX"), + (Integer) commandArguments.get("colorY"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToColorCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToColor", colorControlmoveToColorInteractionInfo); + Map colorControlmoveToColorTemperatureCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = + new CommandParameterInfo("colorTemperature", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "colorTemperature", colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "transitionTime", colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "optionsMask", colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "optionsOverride", colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToColorTemperature( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("colorTemperature"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToColorTemperatureCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToColorTemperature", colorControlmoveToColorTemperatureInteractionInfo); + Map colorControlmoveToHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = + new CommandParameterInfo("hue", Integer.class); + colorControlmoveToHueCommandParams.put("hue", colorControlmoveToHuehueCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = + new CommandParameterInfo("direction", Integer.class); + colorControlmoveToHueCommandParams.put( + "direction", colorControlmoveToHuedirectionCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToHueCommandParams.put( + "transitionTime", colorControlmoveToHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToHueCommandParams.put( + "optionsMask", colorControlmoveToHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToHueCommandParams.put( + "optionsOverride", colorControlmoveToHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("hue"), + (Integer) commandArguments.get("direction"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToHueCommandParams); + colorControlClusterInteractionInfoMap.put("moveToHue", colorControlmoveToHueInteractionInfo); + Map colorControlmoveToHueAndSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = + new CommandParameterInfo("hue", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "hue", colorControlmoveToHueAndSaturationhueCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = + new CommandParameterInfo("saturation", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "saturation", colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "transitionTime", colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "optionsMask", colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "optionsOverride", colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToHueAndSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("hue"), + (Integer) commandArguments.get("saturation"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToHueAndSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToHueAndSaturation", colorControlmoveToHueAndSaturationInteractionInfo); + Map colorControlmoveToSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = + new CommandParameterInfo("saturation", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "saturation", colorControlmoveToSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "transitionTime", colorControlmoveToSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "optionsMask", colorControlmoveToSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "optionsOverride", colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("saturation"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToSaturation", colorControlmoveToSaturationInteractionInfo); + Map colorControlstepColorCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = + new CommandParameterInfo("stepX", Integer.class); + colorControlstepColorCommandParams.put("stepX", colorControlstepColorstepXCommandParameterInfo); + + CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = + new CommandParameterInfo("stepY", Integer.class); + colorControlstepColorCommandParams.put("stepY", colorControlstepColorstepYCommandParameterInfo); + + CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepColorCommandParams.put( + "transitionTime", colorControlstepColortransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepColorCommandParams.put( + "optionsMask", colorControlstepColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepColorCommandParams.put( + "optionsOverride", colorControlstepColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepColorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepColor( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepX"), + (Integer) commandArguments.get("stepY"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepColorCommandParams); + colorControlClusterInteractionInfoMap.put("stepColor", colorControlstepColorInteractionInfo); + Map colorControlstepColorTemperatureCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "stepMode", colorControlstepColorTemperaturestepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "stepSize", colorControlstepColorTemperaturestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "transitionTime", colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); + + CommandParameterInfo + colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMinimum", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "colorTemperatureMinimum", + colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); + + CommandParameterInfo + colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMaximum", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "colorTemperatureMaximum", + colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "optionsMask", colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "optionsOverride", colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepColorTemperatureInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepColorTemperature( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("colorTemperatureMinimum"), + (Integer) commandArguments.get("colorTemperatureMaximum"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepColorTemperatureCommandParams); + colorControlClusterInteractionInfoMap.put( + "stepColorTemperature", colorControlstepColorTemperatureInteractionInfo); + Map colorControlstepHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlstepHueCommandParams.put( + "stepMode", colorControlstepHuestepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlstepHueCommandParams.put( + "stepSize", colorControlstepHuestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepHueCommandParams.put( + "transitionTime", colorControlstepHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepHueCommandParams.put( + "optionsMask", colorControlstepHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepHueCommandParams.put( + "optionsOverride", colorControlstepHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepHueCommandParams); + colorControlClusterInteractionInfoMap.put("stepHue", colorControlstepHueInteractionInfo); + Map colorControlstepSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlstepSaturationCommandParams.put( + "stepMode", colorControlstepSaturationstepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlstepSaturationCommandParams.put( + "stepSize", colorControlstepSaturationstepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepSaturationCommandParams.put( + "transitionTime", colorControlstepSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepSaturationCommandParams.put( + "optionsMask", colorControlstepSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepSaturationCommandParams.put( + "optionsOverride", colorControlstepSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "stepSaturation", colorControlstepSaturationInteractionInfo); + Map colorControlstopMoveStepCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstopMoveStepCommandParams.put( + "optionsMask", colorControlstopMoveStepoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstopMoveStepCommandParams.put( + "optionsOverride", colorControlstopMoveStepoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstopMoveStepInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stopMoveStep( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstopMoveStepCommandParams); + colorControlClusterInteractionInfoMap.put( + "stopMoveStep", colorControlstopMoveStepInteractionInfo); + commandMap.put("colorControl", colorControlClusterInteractionInfoMap); + Map contentLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); + Map contentLauncherlaunchContentRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = + new CommandParameterInfo("autoPlay", Boolean.class); + contentLauncherlaunchContentRequestCommandParams.put( + "autoPlay", contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); + + CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = + new CommandParameterInfo("data", String.class); + contentLauncherlaunchContentRequestCommandParams.put( + "data", contentLauncherlaunchContentRequestdataCommandParameterInfo); + + InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .launchContentRequest( + (ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback, + (Boolean) commandArguments.get("autoPlay"), + (String) commandArguments.get("data"), + (ArrayList) + commandArguments.get("search")); + }, + () -> new DelegatedLaunchResponseCallback(), + contentLauncherlaunchContentRequestCommandParams); + contentLauncherClusterInteractionInfoMap.put( + "launchContentRequest", contentLauncherlaunchContentRequestInteractionInfo); + Map contentLauncherlaunchURLRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = + new CommandParameterInfo("contentURL", String.class); + contentLauncherlaunchURLRequestCommandParams.put( + "contentURL", contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); + + CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = + new CommandParameterInfo("displayString", String.class); + contentLauncherlaunchURLRequestCommandParams.put( + "displayString", contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); + + InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .launchURLRequest( + (ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback, + (String) commandArguments.get("contentURL"), + (String) commandArguments.get("displayString"), + (ChipStructs.ContentLauncherClusterBrandingInformation) + commandArguments.get("brandingInformation")); + }, + () -> new DelegatedLaunchResponseCallback(), + contentLauncherlaunchURLRequestCommandParams); + contentLauncherClusterInteractionInfoMap.put( + "launchURLRequest", contentLauncherlaunchURLRequestInteractionInfo); + commandMap.put("contentLauncher", contentLauncherClusterInteractionInfoMap); + Map descriptorClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("descriptor", descriptorClusterInteractionInfoMap); + Map diagnosticLogsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map diagnosticLogsretrieveLogsRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = + new CommandParameterInfo("intent", Integer.class); + diagnosticLogsretrieveLogsRequestCommandParams.put( + "intent", diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); + + CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = + new CommandParameterInfo("requestedProtocol", Integer.class); + diagnosticLogsretrieveLogsRequestCommandParams.put( + "requestedProtocol", + diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); + + CommandParameterInfo + diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = + new CommandParameterInfo("transferFileDesignator", byte[].class); + diagnosticLogsretrieveLogsRequestCommandParams.put( + "transferFileDesignator", + diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); + + InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .retrieveLogsRequest( + (ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback) callback, + (Integer) commandArguments.get("intent"), + (Integer) commandArguments.get("requestedProtocol"), + (byte[]) commandArguments.get("transferFileDesignator")); + }, + () -> new DelegatedRetrieveLogsResponseCallback(), + diagnosticLogsretrieveLogsRequestCommandParams); + diagnosticLogsClusterInteractionInfoMap.put( + "retrieveLogsRequest", diagnosticLogsretrieveLogsRequestInteractionInfo); + commandMap.put("diagnosticLogs", diagnosticLogsClusterInteractionInfoMap); + Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); + Map doorLockclearCredentialCommandParams = + new LinkedHashMap(); + InteractionInfo doorLockclearCredentialInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearCredential( + (DefaultClusterCallback) callback, + (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearCredentialCommandParams); + doorLockClusterInteractionInfoMap.put( + "clearCredential", doorLockclearCredentialInteractionInfo); + Map doorLockclearUserCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockclearUserCommandParams.put("userIndex", doorLockclearUseruserIndexCommandParameterInfo); + + InteractionInfo doorLockclearUserInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearUser( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("userIndex"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearUserCommandParams); + doorLockClusterInteractionInfoMap.put("clearUser", doorLockclearUserInteractionInfo); + Map doorLockclearWeekDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = + new CommandParameterInfo("weekDayIndex", Integer.class); + doorLockclearWeekDayScheduleCommandParams.put( + "weekDayIndex", doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockclearWeekDayScheduleCommandParams.put( + "userIndex", doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearWeekDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("weekDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearWeekDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "clearWeekDaySchedule", doorLockclearWeekDayScheduleInteractionInfo); + Map doorLockclearYearDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = + new CommandParameterInfo("yearDayIndex", Integer.class); + doorLockclearYearDayScheduleCommandParams.put( + "yearDayIndex", doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockclearYearDayScheduleCommandParams.put( + "userIndex", doorLockclearYearDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockclearYearDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearYearDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("yearDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearYearDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "clearYearDaySchedule", doorLockclearYearDayScheduleInteractionInfo); + Map doorLockgetCredentialStatusCommandParams = + new LinkedHashMap(); + InteractionInfo doorLockgetCredentialStatusInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getCredentialStatus( + (ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback, + (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential")); + }, + () -> new DelegatedGetCredentialStatusResponseCallback(), + doorLockgetCredentialStatusCommandParams); + doorLockClusterInteractionInfoMap.put( + "getCredentialStatus", doorLockgetCredentialStatusInteractionInfo); + Map doorLockgetUserCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockgetUserCommandParams.put("userIndex", doorLockgetUseruserIndexCommandParameterInfo); + + InteractionInfo doorLockgetUserInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getUser( + (ChipClusters.DoorLockCluster.GetUserResponseCallback) callback, + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedGetUserResponseCallback(), + doorLockgetUserCommandParams); + doorLockClusterInteractionInfoMap.put("getUser", doorLockgetUserInteractionInfo); + Map doorLockgetWeekDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = + new CommandParameterInfo("weekDayIndex", Integer.class); + doorLockgetWeekDayScheduleCommandParams.put( + "weekDayIndex", doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockgetWeekDayScheduleCommandParams.put( + "userIndex", doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getWeekDaySchedule( + (ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback) callback, + (Integer) commandArguments.get("weekDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedGetWeekDayScheduleResponseCallback(), + doorLockgetWeekDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "getWeekDaySchedule", doorLockgetWeekDayScheduleInteractionInfo); + Map doorLockgetYearDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = + new CommandParameterInfo("yearDayIndex", Integer.class); + doorLockgetYearDayScheduleCommandParams.put( + "yearDayIndex", doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockgetYearDayScheduleCommandParams.put( + "userIndex", doorLockgetYearDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockgetYearDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getYearDaySchedule( + (ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback) callback, + (Integer) commandArguments.get("yearDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedGetYearDayScheduleResponseCallback(), + doorLockgetYearDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "getYearDaySchedule", doorLockgetYearDayScheduleInteractionInfo); + Map doorLocklockDoorCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = + new CommandParameterInfo("pinCode", Optional.class); + doorLocklockDoorCommandParams.put("pinCode", doorLocklockDoorpinCodeCommandParameterInfo); + + InteractionInfo doorLocklockDoorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .lockDoor( + (DefaultClusterCallback) callback, + (Optional) commandArguments.get("pinCode"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocklockDoorCommandParams); + doorLockClusterInteractionInfoMap.put("lockDoor", doorLocklockDoorInteractionInfo); + Map doorLocksetCredentialCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = + new CommandParameterInfo("operationType", Integer.class); + doorLocksetCredentialCommandParams.put( + "operationType", doorLocksetCredentialoperationTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = + new CommandParameterInfo("credentialData", byte[].class); + doorLocksetCredentialCommandParams.put( + "credentialData", doorLocksetCredentialcredentialDataCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetCredentialCommandParams.put( + "userIndex", doorLocksetCredentialuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = + new CommandParameterInfo("userStatus", Integer.class); + doorLocksetCredentialCommandParams.put( + "userStatus", doorLocksetCredentialuserStatusCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = + new CommandParameterInfo("userType", Integer.class); + doorLocksetCredentialCommandParams.put( + "userType", doorLocksetCredentialuserTypeCommandParameterInfo); + + InteractionInfo doorLocksetCredentialInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setCredential( + (ChipClusters.DoorLockCluster.SetCredentialResponseCallback) callback, + (Integer) commandArguments.get("operationType"), + (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential"), + (byte[]) commandArguments.get("credentialData"), + (Integer) commandArguments.get("userIndex"), + (Integer) commandArguments.get("userStatus"), + (Integer) commandArguments.get("userType"), + 10000); + }, + () -> new DelegatedSetCredentialResponseCallback(), + doorLocksetCredentialCommandParams); + doorLockClusterInteractionInfoMap.put("setCredential", doorLocksetCredentialInteractionInfo); + Map doorLocksetUserCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = + new CommandParameterInfo("operationType", Integer.class); + doorLocksetUserCommandParams.put( + "operationType", doorLocksetUseroperationTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetUserCommandParams.put("userIndex", doorLocksetUseruserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = + new CommandParameterInfo("userName", String.class); + doorLocksetUserCommandParams.put("userName", doorLocksetUseruserNameCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = + new CommandParameterInfo("userUniqueId", Long.class); + doorLocksetUserCommandParams.put( + "userUniqueId", doorLocksetUseruserUniqueIdCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = + new CommandParameterInfo("userStatus", Integer.class); + doorLocksetUserCommandParams.put("userStatus", doorLocksetUseruserStatusCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = + new CommandParameterInfo("userType", Integer.class); + doorLocksetUserCommandParams.put("userType", doorLocksetUseruserTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = + new CommandParameterInfo("credentialRule", Integer.class); + doorLocksetUserCommandParams.put( + "credentialRule", doorLocksetUsercredentialRuleCommandParameterInfo); + + InteractionInfo doorLocksetUserInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setUser( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("operationType"), + (Integer) commandArguments.get("userIndex"), + (String) commandArguments.get("userName"), + (Long) commandArguments.get("userUniqueId"), + (Integer) commandArguments.get("userStatus"), + (Integer) commandArguments.get("userType"), + (Integer) commandArguments.get("credentialRule"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetUserCommandParams); + doorLockClusterInteractionInfoMap.put("setUser", doorLocksetUserInteractionInfo); + Map doorLocksetWeekDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = + new CommandParameterInfo("weekDayIndex", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "weekDayIndex", doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "userIndex", doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = + new CommandParameterInfo("daysMask", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "daysMask", doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = + new CommandParameterInfo("startHour", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "startHour", doorLocksetWeekDaySchedulestartHourCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = + new CommandParameterInfo("startMinute", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "startMinute", doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = + new CommandParameterInfo("endHour", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "endHour", doorLocksetWeekDayScheduleendHourCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = + new CommandParameterInfo("endMinute", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "endMinute", doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); + + InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setWeekDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("weekDayIndex"), + (Integer) commandArguments.get("userIndex"), + (Integer) commandArguments.get("daysMask"), + (Integer) commandArguments.get("startHour"), + (Integer) commandArguments.get("startMinute"), + (Integer) commandArguments.get("endHour"), + (Integer) commandArguments.get("endMinute")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetWeekDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "setWeekDaySchedule", doorLocksetWeekDayScheduleInteractionInfo); + Map doorLocksetYearDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = + new CommandParameterInfo("yearDayIndex", Integer.class); + doorLocksetYearDayScheduleCommandParams.put( + "yearDayIndex", doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetYearDayScheduleCommandParams.put( + "userIndex", doorLocksetYearDayScheduleuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = + new CommandParameterInfo("localStartTime", Long.class); + doorLocksetYearDayScheduleCommandParams.put( + "localStartTime", doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = + new CommandParameterInfo("localEndTime", Long.class); + doorLocksetYearDayScheduleCommandParams.put( + "localEndTime", doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); + + InteractionInfo doorLocksetYearDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setYearDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("yearDayIndex"), + (Integer) commandArguments.get("userIndex"), + (Long) commandArguments.get("localStartTime"), + (Long) commandArguments.get("localEndTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetYearDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "setYearDaySchedule", doorLocksetYearDayScheduleInteractionInfo); + Map doorLockunlockDoorCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = + new CommandParameterInfo("pinCode", Optional.class); + doorLockunlockDoorCommandParams.put("pinCode", doorLockunlockDoorpinCodeCommandParameterInfo); + + InteractionInfo doorLockunlockDoorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .unlockDoor( + (DefaultClusterCallback) callback, + (Optional) commandArguments.get("pinCode"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockunlockDoorCommandParams); + doorLockClusterInteractionInfoMap.put("unlockDoor", doorLockunlockDoorInteractionInfo); + Map doorLockunlockWithTimeoutCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = + new CommandParameterInfo("timeout", Integer.class); + doorLockunlockWithTimeoutCommandParams.put( + "timeout", doorLockunlockWithTimeouttimeoutCommandParameterInfo); + + CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = + new CommandParameterInfo("pinCode", Optional.class); + doorLockunlockWithTimeoutCommandParams.put( + "pinCode", doorLockunlockWithTimeoutpinCodeCommandParameterInfo); + + InteractionInfo doorLockunlockWithTimeoutInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .unlockWithTimeout( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("timeout"), + (Optional) commandArguments.get("pinCode"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockunlockWithTimeoutCommandParams); + doorLockClusterInteractionInfoMap.put( + "unlockWithTimeout", doorLockunlockWithTimeoutInteractionInfo); + commandMap.put("doorLock", doorLockClusterInteractionInfoMap); + Map electricalMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("electricalMeasurement", electricalMeasurementClusterInteractionInfoMap); + Map ethernetNetworkDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map ethernetNetworkDiagnosticsresetCountsCommandParams = + new LinkedHashMap(); + InteractionInfo ethernetNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + ethernetNetworkDiagnosticsresetCountsCommandParams); + ethernetNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", ethernetNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put( + "ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); + Map fixedLabelClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("fixedLabel", fixedLabelClusterInteractionInfoMap); + Map flowMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("flowMeasurement", flowMeasurementClusterInteractionInfoMap); + Map generalCommissioningClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map generalCommissioningarmFailSafeCommandParams = + new LinkedHashMap(); + CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = + new CommandParameterInfo("expiryLengthSeconds", Integer.class); + generalCommissioningarmFailSafeCommandParams.put( + "expiryLengthSeconds", + generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); + + CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + generalCommissioningarmFailSafeCommandParams.put( + "breadcrumb", generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); + + CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = + new CommandParameterInfo("timeoutMs", Long.class); + generalCommissioningarmFailSafeCommandParams.put( + "timeoutMs", generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); + + InteractionInfo generalCommissioningarmFailSafeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .armFailSafe( + (ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback) + callback, + (Integer) commandArguments.get("expiryLengthSeconds"), + (Long) commandArguments.get("breadcrumb"), + (Long) commandArguments.get("timeoutMs")); + }, + () -> new DelegatedArmFailSafeResponseCallback(), + generalCommissioningarmFailSafeCommandParams); + generalCommissioningClusterInteractionInfoMap.put( + "armFailSafe", generalCommissioningarmFailSafeInteractionInfo); + Map generalCommissioningcommissioningCompleteCommandParams = + new LinkedHashMap(); + InteractionInfo generalCommissioningcommissioningCompleteInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .commissioningComplete( + (ChipClusters.GeneralCommissioningCluster + .CommissioningCompleteResponseCallback) + callback); + }, + () -> new DelegatedCommissioningCompleteResponseCallback(), + generalCommissioningcommissioningCompleteCommandParams); + generalCommissioningClusterInteractionInfoMap.put( + "commissioningComplete", generalCommissioningcommissioningCompleteInteractionInfo); + Map generalCommissioningsetRegulatoryConfigCommandParams = + new LinkedHashMap(); + CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = + new CommandParameterInfo("location", Integer.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "location", generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = + new CommandParameterInfo("countryCode", String.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "countryCode", generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "breadcrumb", generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = + new CommandParameterInfo("timeoutMs", Long.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "timeoutMs", generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); + + InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .setRegulatoryConfig( + (ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback) + callback, + (Integer) commandArguments.get("location"), + (String) commandArguments.get("countryCode"), + (Long) commandArguments.get("breadcrumb"), + (Long) commandArguments.get("timeoutMs")); + }, + () -> new DelegatedSetRegulatoryConfigResponseCallback(), + generalCommissioningsetRegulatoryConfigCommandParams); + generalCommissioningClusterInteractionInfoMap.put( + "setRegulatoryConfig", generalCommissioningsetRegulatoryConfigInteractionInfo); + commandMap.put("generalCommissioning", generalCommissioningClusterInteractionInfoMap); + Map generalDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("generalDiagnostics", generalDiagnosticsClusterInteractionInfoMap); + Map groupKeyManagementClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map groupKeyManagementkeySetReadCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = + new CommandParameterInfo("groupKeySetID", Integer.class); + groupKeyManagementkeySetReadCommandParams.put( + "groupKeySetID", groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetReadInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetRead( + (ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback, + (Integer) commandArguments.get("groupKeySetID")); + }, + () -> new DelegatedKeySetReadResponseCallback(), + groupKeyManagementkeySetReadCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetRead", groupKeyManagementkeySetReadInteractionInfo); + Map groupKeyManagementkeySetReadAllIndicesCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = + new CommandParameterInfo("groupKeySetIDs", ArrayList.class); + groupKeyManagementkeySetReadAllIndicesCommandParams.put( + "groupKeySetIDs", groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetReadAllIndices( + (ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) + callback, + (ArrayList) commandArguments.get("groupKeySetIDs")); + }, + () -> new DelegatedKeySetReadAllIndicesResponseCallback(), + groupKeyManagementkeySetReadAllIndicesCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetReadAllIndices", groupKeyManagementkeySetReadAllIndicesInteractionInfo); + Map groupKeyManagementkeySetRemoveCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = + new CommandParameterInfo("groupKeySetID", Integer.class); + groupKeyManagementkeySetRemoveCommandParams.put( + "groupKeySetID", groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetRemove( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("groupKeySetID")); + }, + () -> new DelegatedDefaultClusterCallback(), + groupKeyManagementkeySetRemoveCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetRemove", groupKeyManagementkeySetRemoveInteractionInfo); + Map groupKeyManagementkeySetWriteCommandParams = + new LinkedHashMap(); + InteractionInfo groupKeyManagementkeySetWriteInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetWrite( + (DefaultClusterCallback) callback, + (ChipStructs.GroupKeyManagementClusterGroupKeySet) + commandArguments.get("groupKeySet")); + }, + () -> new DelegatedDefaultClusterCallback(), + groupKeyManagementkeySetWriteCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetWrite", groupKeyManagementkeySetWriteInteractionInfo); + commandMap.put("groupKeyManagement", groupKeyManagementClusterInteractionInfoMap); + Map groupsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map groupsaddGroupCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsaddGroupCommandParams.put("groupId", groupsaddGroupgroupIdCommandParameterInfo); + + CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = + new CommandParameterInfo("groupName", String.class); + groupsaddGroupCommandParams.put("groupName", groupsaddGroupgroupNameCommandParameterInfo); + + InteractionInfo groupsaddGroupInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .addGroup( + (ChipClusters.GroupsCluster.AddGroupResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (String) commandArguments.get("groupName")); + }, + () -> new DelegatedAddGroupResponseCallback(), + groupsaddGroupCommandParams); + groupsClusterInteractionInfoMap.put("addGroup", groupsaddGroupInteractionInfo); + Map groupsaddGroupIfIdentifyingCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsaddGroupIfIdentifyingCommandParams.put( + "groupId", groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); + + CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = + new CommandParameterInfo("groupName", String.class); + groupsaddGroupIfIdentifyingCommandParams.put( + "groupName", groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); + + InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .addGroupIfIdentifying( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("groupId"), + (String) commandArguments.get("groupName")); + }, + () -> new DelegatedDefaultClusterCallback(), + groupsaddGroupIfIdentifyingCommandParams); + groupsClusterInteractionInfoMap.put( + "addGroupIfIdentifying", groupsaddGroupIfIdentifyingInteractionInfo); + Map groupsgetGroupMembershipCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = + new CommandParameterInfo("groupList", ArrayList.class); + groupsgetGroupMembershipCommandParams.put( + "groupList", groupsgetGroupMembershipgroupListCommandParameterInfo); + + InteractionInfo groupsgetGroupMembershipInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .getGroupMembership( + (ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback, + (ArrayList) commandArguments.get("groupList")); + }, + () -> new DelegatedGetGroupMembershipResponseCallback(), + groupsgetGroupMembershipCommandParams); + groupsClusterInteractionInfoMap.put( + "getGroupMembership", groupsgetGroupMembershipInteractionInfo); + Map groupsremoveAllGroupsCommandParams = + new LinkedHashMap(); + InteractionInfo groupsremoveAllGroupsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .removeAllGroups((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + groupsremoveAllGroupsCommandParams); + groupsClusterInteractionInfoMap.put("removeAllGroups", groupsremoveAllGroupsInteractionInfo); + Map groupsremoveGroupCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsremoveGroupCommandParams.put("groupId", groupsremoveGroupgroupIdCommandParameterInfo); + + InteractionInfo groupsremoveGroupInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .removeGroup( + (ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedRemoveGroupResponseCallback(), + groupsremoveGroupCommandParams); + groupsClusterInteractionInfoMap.put("removeGroup", groupsremoveGroupInteractionInfo); + Map groupsviewGroupCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsviewGroupCommandParams.put("groupId", groupsviewGroupgroupIdCommandParameterInfo); + + InteractionInfo groupsviewGroupInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .viewGroup( + (ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedViewGroupResponseCallback(), + groupsviewGroupCommandParams); + groupsClusterInteractionInfoMap.put("viewGroup", groupsviewGroupInteractionInfo); + commandMap.put("groups", groupsClusterInteractionInfoMap); + Map identifyClusterInteractionInfoMap = new LinkedHashMap<>(); + Map identifyidentifyCommandParams = + new LinkedHashMap(); + CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = + new CommandParameterInfo("identifyTime", Integer.class); + identifyidentifyCommandParams.put( + "identifyTime", identifyidentifyidentifyTimeCommandParameterInfo); + + InteractionInfo identifyidentifyInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .identify( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("identifyTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + identifyidentifyCommandParams); + identifyClusterInteractionInfoMap.put("identify", identifyidentifyInteractionInfo); + Map identifyidentifyQueryCommandParams = + new LinkedHashMap(); + InteractionInfo identifyidentifyQueryInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .identifyQuery( + (ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback); + }, + () -> new DelegatedIdentifyQueryResponseCallback(), + identifyidentifyQueryCommandParams); + identifyClusterInteractionInfoMap.put("identifyQuery", identifyidentifyQueryInteractionInfo); + Map identifytriggerEffectCommandParams = + new LinkedHashMap(); + CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = + new CommandParameterInfo("effectIdentifier", Integer.class); + identifytriggerEffectCommandParams.put( + "effectIdentifier", identifytriggerEffecteffectIdentifierCommandParameterInfo); + + CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = + new CommandParameterInfo("effectVariant", Integer.class); + identifytriggerEffectCommandParams.put( + "effectVariant", identifytriggerEffecteffectVariantCommandParameterInfo); + + InteractionInfo identifytriggerEffectInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .triggerEffect( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("effectIdentifier"), + (Integer) commandArguments.get("effectVariant")); + }, + () -> new DelegatedDefaultClusterCallback(), + identifytriggerEffectCommandParams); + identifyClusterInteractionInfoMap.put("triggerEffect", identifytriggerEffectInteractionInfo); + commandMap.put("identify", identifyClusterInteractionInfoMap); + Map illuminanceMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInteractionInfoMap); + Map keypadInputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map keypadInputsendKeyRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = + new CommandParameterInfo("keyCode", Integer.class); + keypadInputsendKeyRequestCommandParams.put( + "keyCode", keypadInputsendKeyRequestkeyCodeCommandParameterInfo); + + InteractionInfo keypadInputsendKeyRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .sendKeyRequest( + (ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback, + (Integer) commandArguments.get("keyCode")); + }, + () -> new DelegatedSendKeyResponseCallback(), + keypadInputsendKeyRequestCommandParams); + keypadInputClusterInteractionInfoMap.put( + "sendKeyRequest", keypadInputsendKeyRequestInteractionInfo); + commandMap.put("keypadInput", keypadInputClusterInteractionInfoMap); + Map levelControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map levelControlmoveCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + levelControlmoveCommandParams.put("moveMode", levelControlmovemoveModeCommandParameterInfo); + + CommandParameterInfo levelControlmoverateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + levelControlmoveCommandParams.put("rate", levelControlmoverateCommandParameterInfo); + + CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlmoveCommandParams.put("optionMask", levelControlmoveoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlmoveCommandParams.put( + "optionOverride", levelControlmoveoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlmoveInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .move( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveCommandParams); + levelControlClusterInteractionInfoMap.put("move", levelControlmoveInteractionInfo); + Map levelControlmoveToLevelCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = + new CommandParameterInfo("level", Integer.class); + levelControlmoveToLevelCommandParams.put( + "level", levelControlmoveToLevellevelCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlmoveToLevelCommandParams.put( + "transitionTime", levelControlmoveToLeveltransitionTimeCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlmoveToLevelCommandParams.put( + "optionMask", levelControlmoveToLeveloptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlmoveToLevelCommandParams.put( + "optionOverride", levelControlmoveToLeveloptionOverrideCommandParameterInfo); + + InteractionInfo levelControlmoveToLevelInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveToLevel( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("level"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveToLevelCommandParams); + levelControlClusterInteractionInfoMap.put( + "moveToLevel", levelControlmoveToLevelInteractionInfo); + Map levelControlmoveToLevelWithOnOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = + new CommandParameterInfo("level", Integer.class); + levelControlmoveToLevelWithOnOffCommandParams.put( + "level", levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlmoveToLevelWithOnOffCommandParams.put( + "transitionTime", levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); + + InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveToLevelWithOnOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("level"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveToLevelWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffInteractionInfo); + Map levelControlmoveWithOnOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + levelControlmoveWithOnOffCommandParams.put( + "moveMode", levelControlmoveWithOnOffmoveModeCommandParameterInfo); + + CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + levelControlmoveWithOnOffCommandParams.put( + "rate", levelControlmoveWithOnOffrateCommandParameterInfo); + + InteractionInfo levelControlmoveWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveWithOnOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "moveWithOnOff", levelControlmoveWithOnOffInteractionInfo); + Map levelControlstepCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlstepstepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + levelControlstepCommandParams.put("stepMode", levelControlstepstepModeCommandParameterInfo); + + CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + levelControlstepCommandParams.put("stepSize", levelControlstepstepSizeCommandParameterInfo); + + CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlstepCommandParams.put( + "transitionTime", levelControlsteptransitionTimeCommandParameterInfo); + + CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlstepCommandParams.put("optionMask", levelControlstepoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlstepCommandParams.put( + "optionOverride", levelControlstepoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlstepInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .step( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstepCommandParams); + levelControlClusterInteractionInfoMap.put("step", levelControlstepInteractionInfo); + Map levelControlstepWithOnOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + levelControlstepWithOnOffCommandParams.put( + "stepMode", levelControlstepWithOnOffstepModeCommandParameterInfo); + + CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + levelControlstepWithOnOffCommandParams.put( + "stepSize", levelControlstepWithOnOffstepSizeCommandParameterInfo); + + CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlstepWithOnOffCommandParams.put( + "transitionTime", levelControlstepWithOnOfftransitionTimeCommandParameterInfo); + + InteractionInfo levelControlstepWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stepWithOnOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstepWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "stepWithOnOff", levelControlstepWithOnOffInteractionInfo); + Map levelControlstopCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlstopCommandParams.put("optionMask", levelControlstopoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlstopCommandParams.put( + "optionOverride", levelControlstopoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlstopInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stop( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstopCommandParams); + levelControlClusterInteractionInfoMap.put("stop", levelControlstopInteractionInfo); + Map levelControlstopWithOnOffCommandParams = + new LinkedHashMap(); + InteractionInfo levelControlstopWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stopWithOnOff((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstopWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "stopWithOnOff", levelControlstopWithOnOffInteractionInfo); + commandMap.put("levelControl", levelControlClusterInteractionInfoMap); + Map localizationConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("localizationConfiguration", localizationConfigurationClusterInteractionInfoMap); + Map lowPowerClusterInteractionInfoMap = new LinkedHashMap<>(); + Map lowPowersleepCommandParams = + new LinkedHashMap(); + InteractionInfo lowPowersleepInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).sleep((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + lowPowersleepCommandParams); + lowPowerClusterInteractionInfoMap.put("sleep", lowPowersleepInteractionInfo); + commandMap.put("lowPower", lowPowerClusterInteractionInfoMap); + Map mediaInputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map mediaInputhideInputStatusRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaInputhideInputStatusRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .hideInputStatusRequest((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputhideInputStatusRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "hideInputStatusRequest", mediaInputhideInputStatusRequestInteractionInfo); + Map mediaInputrenameInputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + mediaInputrenameInputRequestCommandParams.put( + "index", mediaInputrenameInputRequestindexCommandParameterInfo); + + CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = + new CommandParameterInfo("name", String.class); + mediaInputrenameInputRequestCommandParams.put( + "name", mediaInputrenameInputRequestnameCommandParameterInfo); + + InteractionInfo mediaInputrenameInputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .renameInputRequest( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("index"), + (String) commandArguments.get("name")); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputrenameInputRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "renameInputRequest", mediaInputrenameInputRequestInteractionInfo); + Map mediaInputselectInputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + mediaInputselectInputRequestCommandParams.put( + "index", mediaInputselectInputRequestindexCommandParameterInfo); + + InteractionInfo mediaInputselectInputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .selectInputRequest( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("index")); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputselectInputRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "selectInputRequest", mediaInputselectInputRequestInteractionInfo); + Map mediaInputshowInputStatusRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaInputshowInputStatusRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .showInputStatusRequest((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputshowInputStatusRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "showInputStatusRequest", mediaInputshowInputStatusRequestInteractionInfo); + commandMap.put("mediaInput", mediaInputClusterInteractionInfoMap); + Map mediaPlaybackClusterInteractionInfoMap = new LinkedHashMap<>(); + Map mediaPlaybackfastForwardRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackfastForwardRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .fastForwardRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackfastForwardRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "fastForwardRequest", mediaPlaybackfastForwardRequestInteractionInfo); + Map mediaPlaybacknextRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybacknextRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .nextRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybacknextRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "nextRequest", mediaPlaybacknextRequestInteractionInfo); + Map mediaPlaybackpauseRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackpauseRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .pauseRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackpauseRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "pauseRequest", mediaPlaybackpauseRequestInteractionInfo); + Map mediaPlaybackplayRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackplayRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .playRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackplayRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "playRequest", mediaPlaybackplayRequestInteractionInfo); + Map mediaPlaybackpreviousRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackpreviousRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .previousRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackpreviousRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "previousRequest", mediaPlaybackpreviousRequestInteractionInfo); + Map mediaPlaybackrewindRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackrewindRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .rewindRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackrewindRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "rewindRequest", mediaPlaybackrewindRequestInteractionInfo); + Map mediaPlaybackseekRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = + new CommandParameterInfo("position", Long.class); + mediaPlaybackseekRequestCommandParams.put( + "position", mediaPlaybackseekRequestpositionCommandParameterInfo); + + InteractionInfo mediaPlaybackseekRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .seekRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, + (Long) commandArguments.get("position")); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackseekRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "seekRequest", mediaPlaybackseekRequestInteractionInfo); + Map mediaPlaybackskipBackwardRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = + new CommandParameterInfo("deltaPositionMilliseconds", Long.class); + mediaPlaybackskipBackwardRequestCommandParams.put( + "deltaPositionMilliseconds", + mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); + + InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .skipBackwardRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, + (Long) commandArguments.get("deltaPositionMilliseconds")); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackskipBackwardRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "skipBackwardRequest", mediaPlaybackskipBackwardRequestInteractionInfo); + Map mediaPlaybackskipForwardRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = + new CommandParameterInfo("deltaPositionMilliseconds", Long.class); + mediaPlaybackskipForwardRequestCommandParams.put( + "deltaPositionMilliseconds", + mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); + + InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .skipForwardRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, + (Long) commandArguments.get("deltaPositionMilliseconds")); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackskipForwardRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "skipForwardRequest", mediaPlaybackskipForwardRequestInteractionInfo); + Map mediaPlaybackstartOverRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackstartOverRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .startOverRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackstartOverRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "startOverRequest", mediaPlaybackstartOverRequestInteractionInfo); + Map mediaPlaybackstopRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackstopRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .stopRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackstopRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "stopRequest", mediaPlaybackstopRequestInteractionInfo); + commandMap.put("mediaPlayback", mediaPlaybackClusterInteractionInfoMap); + Map modeSelectClusterInteractionInfoMap = new LinkedHashMap<>(); + Map modeSelectchangeToModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = + new CommandParameterInfo("newMode", Integer.class); + modeSelectchangeToModeCommandParams.put( + "newMode", modeSelectchangeToModenewModeCommandParameterInfo); + + InteractionInfo modeSelectchangeToModeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .changeToMode( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("newMode")); + }, + () -> new DelegatedDefaultClusterCallback(), + modeSelectchangeToModeCommandParams); + modeSelectClusterInteractionInfoMap.put("changeToMode", modeSelectchangeToModeInteractionInfo); + commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); + Map networkCommissioningClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo + networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = + new CommandParameterInfo("operationalDataset", byte[].class); + networkCommissioningaddOrUpdateThreadNetworkCommandParams.put( + "operationalDataset", + networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); + + CommandParameterInfo + networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningaddOrUpdateThreadNetworkCommandParams.put( + "breadcrumb", networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .addOrUpdateThreadNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("operationalDataset"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningaddOrUpdateThreadNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "addOrUpdateThreadNetwork", networkCommissioningaddOrUpdateThreadNetworkInteractionInfo); + Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = + new CommandParameterInfo("ssid", byte[].class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( + "ssid", networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = + new CommandParameterInfo("credentials", byte[].class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( + "credentials", networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( + "breadcrumb", networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .addOrUpdateWiFiNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("ssid"), + (byte[]) commandArguments.get("credentials"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningaddOrUpdateWiFiNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "addOrUpdateWiFiNetwork", networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo); + Map networkCommissioningconnectNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = + new CommandParameterInfo("networkID", byte[].class); + networkCommissioningconnectNetworkCommandParams.put( + "networkID", networkCommissioningconnectNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningconnectNetworkCommandParams.put( + "breadcrumb", networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningconnectNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .connectNetwork( + (ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback) + callback, + (byte[]) commandArguments.get("networkID"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedConnectNetworkResponseCallback(), + networkCommissioningconnectNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "connectNetwork", networkCommissioningconnectNetworkInteractionInfo); + Map networkCommissioningremoveNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = + new CommandParameterInfo("networkID", byte[].class); + networkCommissioningremoveNetworkCommandParams.put( + "networkID", networkCommissioningremoveNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningremoveNetworkCommandParams.put( + "breadcrumb", networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningremoveNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .removeNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("networkID"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningremoveNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "removeNetwork", networkCommissioningremoveNetworkInteractionInfo); + Map networkCommissioningreorderNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = + new CommandParameterInfo("networkID", byte[].class); + networkCommissioningreorderNetworkCommandParams.put( + "networkID", networkCommissioningreorderNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = + new CommandParameterInfo("networkIndex", Integer.class); + networkCommissioningreorderNetworkCommandParams.put( + "networkIndex", networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); + + CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningreorderNetworkCommandParams.put( + "breadcrumb", networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningreorderNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .reorderNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("networkID"), + (Integer) commandArguments.get("networkIndex"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningreorderNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "reorderNetwork", networkCommissioningreorderNetworkInteractionInfo); + Map networkCommissioningscanNetworksCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = + new CommandParameterInfo("ssid", byte[].class); + networkCommissioningscanNetworksCommandParams.put( + "ssid", networkCommissioningscanNetworksssidCommandParameterInfo); + + CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningscanNetworksCommandParams.put( + "breadcrumb", networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningscanNetworksInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .scanNetworks( + (ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback) + callback, + (byte[]) commandArguments.get("ssid"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedScanNetworksResponseCallback(), + networkCommissioningscanNetworksCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "scanNetworks", networkCommissioningscanNetworksInteractionInfo); + commandMap.put("networkCommissioning", networkCommissioningClusterInteractionInfoMap); + Map otaSoftwareUpdateProviderClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = + new CommandParameterInfo("updateToken", byte[].class); + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put( + "updateToken", otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = + new CommandParameterInfo("newVersion", Long.class); + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put( + "newVersion", otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .applyUpdateRequest( + (ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback) + callback, + (byte[]) commandArguments.get("updateToken"), + (Long) commandArguments.get("newVersion")); + }, + () -> new DelegatedApplyUpdateResponseCallback(), + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo); + Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = + new LinkedHashMap(); + CommandParameterInfo + otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = + new CommandParameterInfo("updateToken", byte[].class); + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put( + "updateToken", otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = + new CommandParameterInfo("softwareVersion", Long.class); + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put( + "softwareVersion", + otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .notifyUpdateApplied( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("updateToken"), + (Long) commandArguments.get("softwareVersion")); + }, + () -> new DelegatedDefaultClusterCallback(), + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo); + Map otaSoftwareUpdateProviderqueryImageCommandParams = + new LinkedHashMap(); + CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = + new CommandParameterInfo("vendorId", Integer.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "vendorId", otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = + new CommandParameterInfo("productId", Integer.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "productId", otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = + new CommandParameterInfo("softwareVersion", Long.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "softwareVersion", otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = + new CommandParameterInfo("protocolsSupported", ArrayList.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "protocolsSupported", + otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = + new CommandParameterInfo("hardwareVersion", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "hardwareVersion", otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = + new CommandParameterInfo("location", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "location", otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = + new CommandParameterInfo("requestorCanConsent", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "requestorCanConsent", + otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = + new CommandParameterInfo("metadataForProvider", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "metadataForProvider", + otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .queryImage( + (ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback) + callback, + (Integer) commandArguments.get("vendorId"), + (Integer) commandArguments.get("productId"), + (Long) commandArguments.get("softwareVersion"), + (ArrayList) commandArguments.get("protocolsSupported"), + (Optional) commandArguments.get("hardwareVersion"), + (Optional) commandArguments.get("location"), + (Optional) commandArguments.get("requestorCanConsent"), + (Optional) commandArguments.get("metadataForProvider")); + }, + () -> new DelegatedQueryImageResponseCallback(), + otaSoftwareUpdateProviderqueryImageCommandParams); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "queryImage", otaSoftwareUpdateProviderqueryImageInteractionInfo); + commandMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInteractionInfoMap); + Map otaSoftwareUpdateRequestorClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = + new LinkedHashMap(); + CommandParameterInfo + otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = + new CommandParameterInfo("providerNodeId", Long.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "providerNodeId", + otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = + new CommandParameterInfo("vendorId", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "vendorId", otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = + new CommandParameterInfo("announcementReason", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "announcementReason", + otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = + new CommandParameterInfo("metadataForNode", Optional.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "metadataForNode", + otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = + new CommandParameterInfo("endpoint", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "endpoint", otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .announceOtaProvider( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("providerNodeId"), + (Integer) commandArguments.get("vendorId"), + (Integer) commandArguments.get("announcementReason"), + (Optional) commandArguments.get("metadataForNode"), + (Integer) commandArguments.get("endpoint")); + }, + () -> new DelegatedDefaultClusterCallback(), + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams); + otaSoftwareUpdateRequestorClusterInteractionInfoMap.put( + "announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo); + commandMap.put( + "otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInteractionInfoMap); + Map occupancySensingClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("occupancySensing", occupancySensingClusterInteractionInfoMap); + Map onOffClusterInteractionInfoMap = new LinkedHashMap<>(); + Map onOffoffCommandParams = + new LinkedHashMap(); + InteractionInfo onOffoffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).off((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffoffCommandParams); + onOffClusterInteractionInfoMap.put("off", onOffoffInteractionInfo); + Map onOffoffWithEffectCommandParams = + new LinkedHashMap(); + CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = + new CommandParameterInfo("effectId", Integer.class); + onOffoffWithEffectCommandParams.put("effectId", onOffoffWithEffecteffectIdCommandParameterInfo); + + CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = + new CommandParameterInfo("effectVariant", Integer.class); + onOffoffWithEffectCommandParams.put( + "effectVariant", onOffoffWithEffecteffectVariantCommandParameterInfo); + + InteractionInfo onOffoffWithEffectInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .offWithEffect( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("effectId"), + (Integer) commandArguments.get("effectVariant")); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffoffWithEffectCommandParams); + onOffClusterInteractionInfoMap.put("offWithEffect", onOffoffWithEffectInteractionInfo); + Map onOffonCommandParams = + new LinkedHashMap(); + InteractionInfo onOffonInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).on((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonCommandParams); + onOffClusterInteractionInfoMap.put("on", onOffonInteractionInfo); + Map onOffonWithRecallGlobalSceneCommandParams = + new LinkedHashMap(); + InteractionInfo onOffonWithRecallGlobalSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .onWithRecallGlobalScene((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonWithRecallGlobalSceneCommandParams); + onOffClusterInteractionInfoMap.put( + "onWithRecallGlobalScene", onOffonWithRecallGlobalSceneInteractionInfo); + Map onOffonWithTimedOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = + new CommandParameterInfo("onOffControl", Integer.class); + onOffonWithTimedOffCommandParams.put( + "onOffControl", onOffonWithTimedOffonOffControlCommandParameterInfo); + + CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = + new CommandParameterInfo("onTime", Integer.class); + onOffonWithTimedOffCommandParams.put("onTime", onOffonWithTimedOffonTimeCommandParameterInfo); + + CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = + new CommandParameterInfo("offWaitTime", Integer.class); + onOffonWithTimedOffCommandParams.put( + "offWaitTime", onOffonWithTimedOffoffWaitTimeCommandParameterInfo); + + InteractionInfo onOffonWithTimedOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .onWithTimedOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("onOffControl"), + (Integer) commandArguments.get("onTime"), + (Integer) commandArguments.get("offWaitTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonWithTimedOffCommandParams); + onOffClusterInteractionInfoMap.put("onWithTimedOff", onOffonWithTimedOffInteractionInfo); + Map onOfftoggleCommandParams = + new LinkedHashMap(); + InteractionInfo onOfftoggleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).toggle((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOfftoggleCommandParams); + onOffClusterInteractionInfoMap.put("toggle", onOfftoggleInteractionInfo); + commandMap.put("onOff", onOffClusterInteractionInfoMap); + Map onOffSwitchConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInteractionInfoMap); + Map operationalCredentialsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map operationalCredentialsaddNOCCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = + new CommandParameterInfo("NOCValue", byte[].class); + operationalCredentialsaddNOCCommandParams.put( + "NOCValue", operationalCredentialsaddNOCNOCValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = + new CommandParameterInfo("ICACValue", Optional.class); + operationalCredentialsaddNOCCommandParams.put( + "ICACValue", operationalCredentialsaddNOCICACValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = + new CommandParameterInfo("IPKValue", byte[].class); + operationalCredentialsaddNOCCommandParams.put( + "IPKValue", operationalCredentialsaddNOCIPKValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = + new CommandParameterInfo("caseAdminNode", Long.class); + operationalCredentialsaddNOCCommandParams.put( + "caseAdminNode", operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = + new CommandParameterInfo("adminVendorId", Integer.class); + operationalCredentialsaddNOCCommandParams.put( + "adminVendorId", operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); + + InteractionInfo operationalCredentialsaddNOCInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .addNOC( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (byte[]) commandArguments.get("NOCValue"), + (Optional) commandArguments.get("ICACValue"), + (byte[]) commandArguments.get("IPKValue"), + (Long) commandArguments.get("caseAdminNode"), + (Integer) commandArguments.get("adminVendorId")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsaddNOCCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "addNOC", operationalCredentialsaddNOCInteractionInfo); + Map operationalCredentialsaddTrustedRootCertificateCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = + new CommandParameterInfo("rootCertificate", byte[].class); + operationalCredentialsaddTrustedRootCertificateCommandParams.put( + "rootCertificate", + operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); + + InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .addTrustedRootCertificate( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("rootCertificate")); + }, + () -> new DelegatedDefaultClusterCallback(), + operationalCredentialsaddTrustedRootCertificateCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "addTrustedRootCertificate", + operationalCredentialsaddTrustedRootCertificateInteractionInfo); + Map operationalCredentialsattestationRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = + new CommandParameterInfo("attestationNonce", byte[].class); + operationalCredentialsattestationRequestCommandParams.put( + "attestationNonce", + operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); + + InteractionInfo operationalCredentialsattestationRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .attestationRequest( + (ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) + callback, + (byte[]) commandArguments.get("attestationNonce")); + }, + () -> new DelegatedAttestationResponseCallback(), + operationalCredentialsattestationRequestCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "attestationRequest", operationalCredentialsattestationRequestInteractionInfo); + Map operationalCredentialscertificateChainRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = + new CommandParameterInfo("certificateType", Integer.class); + operationalCredentialscertificateChainRequestCommandParams.put( + "certificateType", + operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); + + InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .certificateChainRequest( + (ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) + callback, + (Integer) commandArguments.get("certificateType")); + }, + () -> new DelegatedCertificateChainResponseCallback(), + operationalCredentialscertificateChainRequestCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "certificateChainRequest", operationalCredentialscertificateChainRequestInteractionInfo); + Map operationalCredentialsopCSRRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = + new CommandParameterInfo("CSRNonce", byte[].class); + operationalCredentialsopCSRRequestCommandParams.put( + "CSRNonce", operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); + + InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .opCSRRequest( + (ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback, + (byte[]) commandArguments.get("CSRNonce")); + }, + () -> new DelegatedOpCSRResponseCallback(), + operationalCredentialsopCSRRequestCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "opCSRRequest", operationalCredentialsopCSRRequestInteractionInfo); + Map operationalCredentialsremoveFabricCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = + new CommandParameterInfo("fabricIndex", Integer.class); + operationalCredentialsremoveFabricCommandParams.put( + "fabricIndex", operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); + + InteractionInfo operationalCredentialsremoveFabricInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .removeFabric( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (Integer) commandArguments.get("fabricIndex")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsremoveFabricCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "removeFabric", operationalCredentialsremoveFabricInteractionInfo); + Map + operationalCredentialsremoveTrustedRootCertificateCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = + new CommandParameterInfo("trustedRootIdentifier", byte[].class); + operationalCredentialsremoveTrustedRootCertificateCommandParams.put( + "trustedRootIdentifier", + operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); + + InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .removeTrustedRootCertificate( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("trustedRootIdentifier")); + }, + () -> new DelegatedDefaultClusterCallback(), + operationalCredentialsremoveTrustedRootCertificateCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "removeTrustedRootCertificate", + operationalCredentialsremoveTrustedRootCertificateInteractionInfo); + Map operationalCredentialsupdateFabricLabelCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = + new CommandParameterInfo("label", String.class); + operationalCredentialsupdateFabricLabelCommandParams.put( + "label", operationalCredentialsupdateFabricLabellabelCommandParameterInfo); + + InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .updateFabricLabel( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (String) commandArguments.get("label")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsupdateFabricLabelCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "updateFabricLabel", operationalCredentialsupdateFabricLabelInteractionInfo); + Map operationalCredentialsupdateNOCCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = + new CommandParameterInfo("NOCValue", byte[].class); + operationalCredentialsupdateNOCCommandParams.put( + "NOCValue", operationalCredentialsupdateNOCNOCValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = + new CommandParameterInfo("ICACValue", Optional.class); + operationalCredentialsupdateNOCCommandParams.put( + "ICACValue", operationalCredentialsupdateNOCICACValueCommandParameterInfo); + + InteractionInfo operationalCredentialsupdateNOCInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .updateNOC( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (byte[]) commandArguments.get("NOCValue"), + (Optional) commandArguments.get("ICACValue")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsupdateNOCCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "updateNOC", operationalCredentialsupdateNOCInteractionInfo); + commandMap.put("operationalCredentials", operationalCredentialsClusterInteractionInfoMap); + Map powerSourceClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("powerSource", powerSourceClusterInteractionInfoMap); + Map powerSourceConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInteractionInfoMap); + Map pressureMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("pressureMeasurement", pressureMeasurementClusterInteractionInfoMap); + Map pumpConfigurationAndControlClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put( + "pumpConfigurationAndControl", pumpConfigurationAndControlClusterInteractionInfoMap); + Map relativeHumidityMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put( + "relativeHumidityMeasurement", relativeHumidityMeasurementClusterInteractionInfoMap); + Map scenesClusterInteractionInfoMap = new LinkedHashMap<>(); + Map scenesaddSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesaddSceneCommandParams.put("groupId", scenesaddScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesaddSceneCommandParams.put("sceneId", scenesaddScenesceneIdCommandParameterInfo); + + CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + scenesaddSceneCommandParams.put( + "transitionTime", scenesaddScenetransitionTimeCommandParameterInfo); + + CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = + new CommandParameterInfo("sceneName", String.class); + scenesaddSceneCommandParams.put("sceneName", scenesaddScenesceneNameCommandParameterInfo); + + InteractionInfo scenesaddSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .addScene( + (ChipClusters.ScenesCluster.AddSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId"), + (Integer) commandArguments.get("transitionTime"), + (String) commandArguments.get("sceneName"), + (ArrayList) + commandArguments.get("extensionFieldSets")); + }, + () -> new DelegatedAddSceneResponseCallback(), + scenesaddSceneCommandParams); + scenesClusterInteractionInfoMap.put("addScene", scenesaddSceneInteractionInfo); + Map scenesgetSceneMembershipCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesgetSceneMembershipCommandParams.put( + "groupId", scenesgetSceneMembershipgroupIdCommandParameterInfo); + + InteractionInfo scenesgetSceneMembershipInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .getSceneMembership( + (ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedGetSceneMembershipResponseCallback(), + scenesgetSceneMembershipCommandParams); + scenesClusterInteractionInfoMap.put( + "getSceneMembership", scenesgetSceneMembershipInteractionInfo); + Map scenesrecallSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesrecallSceneCommandParams.put("groupId", scenesrecallScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesrecallSceneCommandParams.put("sceneId", scenesrecallScenesceneIdCommandParameterInfo); + + CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + scenesrecallSceneCommandParams.put( + "transitionTime", scenesrecallScenetransitionTimeCommandParameterInfo); + + InteractionInfo scenesrecallSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .recallScene( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + scenesrecallSceneCommandParams); + scenesClusterInteractionInfoMap.put("recallScene", scenesrecallSceneInteractionInfo); + Map scenesremoveAllScenesCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesremoveAllScenesCommandParams.put( + "groupId", scenesremoveAllScenesgroupIdCommandParameterInfo); + + InteractionInfo scenesremoveAllScenesInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .removeAllScenes( + (ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedRemoveAllScenesResponseCallback(), + scenesremoveAllScenesCommandParams); + scenesClusterInteractionInfoMap.put("removeAllScenes", scenesremoveAllScenesInteractionInfo); + Map scenesremoveSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesremoveSceneCommandParams.put("groupId", scenesremoveScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesremoveSceneCommandParams.put("sceneId", scenesremoveScenesceneIdCommandParameterInfo); + + InteractionInfo scenesremoveSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .removeScene( + (ChipClusters.ScenesCluster.RemoveSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId")); + }, + () -> new DelegatedRemoveSceneResponseCallback(), + scenesremoveSceneCommandParams); + scenesClusterInteractionInfoMap.put("removeScene", scenesremoveSceneInteractionInfo); + Map scenesstoreSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesstoreSceneCommandParams.put("groupId", scenesstoreScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesstoreSceneCommandParams.put("sceneId", scenesstoreScenesceneIdCommandParameterInfo); + + InteractionInfo scenesstoreSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .storeScene( + (ChipClusters.ScenesCluster.StoreSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId")); + }, + () -> new DelegatedStoreSceneResponseCallback(), + scenesstoreSceneCommandParams); + scenesClusterInteractionInfoMap.put("storeScene", scenesstoreSceneInteractionInfo); + Map scenesviewSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesviewSceneCommandParams.put("groupId", scenesviewScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesviewSceneCommandParams.put("sceneId", scenesviewScenesceneIdCommandParameterInfo); + + InteractionInfo scenesviewSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .viewScene( + (ChipClusters.ScenesCluster.ViewSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId")); + }, + () -> new DelegatedViewSceneResponseCallback(), + scenesviewSceneCommandParams); + scenesClusterInteractionInfoMap.put("viewScene", scenesviewSceneInteractionInfo); + commandMap.put("scenes", scenesClusterInteractionInfoMap); + Map softwareDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map softwareDiagnosticsresetWatermarksCommandParams = + new LinkedHashMap(); + InteractionInfo softwareDiagnosticsresetWatermarksInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .resetWatermarks((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + softwareDiagnosticsresetWatermarksCommandParams); + softwareDiagnosticsClusterInteractionInfoMap.put( + "resetWatermarks", softwareDiagnosticsresetWatermarksInteractionInfo); + commandMap.put("softwareDiagnostics", softwareDiagnosticsClusterInteractionInfoMap); + Map switchClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("switch", switchClusterInteractionInfoMap); + Map targetNavigatorClusterInteractionInfoMap = new LinkedHashMap<>(); + Map targetNavigatornavigateTargetRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = + new CommandParameterInfo("target", Integer.class); + targetNavigatornavigateTargetRequestCommandParams.put( + "target", targetNavigatornavigateTargetRequesttargetCommandParameterInfo); + + CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = + new CommandParameterInfo("data", String.class); + targetNavigatornavigateTargetRequestCommandParams.put( + "data", targetNavigatornavigateTargetRequestdataCommandParameterInfo); + + InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .navigateTargetRequest( + (ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback) callback, + (Integer) commandArguments.get("target"), + (String) commandArguments.get("data")); + }, + () -> new DelegatedNavigateTargetResponseCallback(), + targetNavigatornavigateTargetRequestCommandParams); + targetNavigatorClusterInteractionInfoMap.put( + "navigateTargetRequest", targetNavigatornavigateTargetRequestInteractionInfo); + commandMap.put("targetNavigator", targetNavigatorClusterInteractionInfoMap); + Map temperatureMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); + Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); + Map testClustersimpleStructEchoRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustersimpleStructEchoRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .simpleStructEchoRequest( + (ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback, + (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1")); + }, + () -> new DelegatedSimpleStructResponseCallback(), + testClustersimpleStructEchoRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "simpleStructEchoRequest", testClustersimpleStructEchoRequestInteractionInfo); + Map testClustertestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).test((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestCommandParams); + testClusterClusterInteractionInfoMap.put("test", testClustertestInteractionInfo); + Map testClustertestAddArgumentsCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Integer.class); + testClustertestAddArgumentsCommandParams.put( + "arg1", testClustertestAddArgumentsarg1CommandParameterInfo); + + CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = + new CommandParameterInfo("arg2", Integer.class); + testClustertestAddArgumentsCommandParams.put( + "arg2", testClustertestAddArgumentsarg2CommandParameterInfo); + + InteractionInfo testClustertestAddArgumentsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testAddArguments( + (ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback) callback, + (Integer) commandArguments.get("arg1"), + (Integer) commandArguments.get("arg2")); + }, + () -> new DelegatedTestAddArgumentsResponseCallback(), + testClustertestAddArgumentsCommandParams); + testClusterClusterInteractionInfoMap.put( + "testAddArguments", testClustertestAddArgumentsInteractionInfo); + Map testClustertestEmitTestEventRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Integer.class); + testClustertestEmitTestEventRequestCommandParams.put( + "arg1", testClustertestEmitTestEventRequestarg1CommandParameterInfo); + + CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = + new CommandParameterInfo("arg2", Integer.class); + testClustertestEmitTestEventRequestCommandParams.put( + "arg2", testClustertestEmitTestEventRequestarg2CommandParameterInfo); + + CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = + new CommandParameterInfo("arg3", Boolean.class); + testClustertestEmitTestEventRequestCommandParams.put( + "arg3", testClustertestEmitTestEventRequestarg3CommandParameterInfo); + + InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testEmitTestEventRequest( + (ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback) callback, + (Integer) commandArguments.get("arg1"), + (Integer) commandArguments.get("arg2"), + (Boolean) commandArguments.get("arg3")); + }, + () -> new DelegatedTestEmitTestEventResponseCallback(), + testClustertestEmitTestEventRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testEmitTestEventRequest", testClustertestEmitTestEventRequestInteractionInfo); + Map testClustertestEnumsRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Integer.class); + testClustertestEnumsRequestCommandParams.put( + "arg1", testClustertestEnumsRequestarg1CommandParameterInfo); + + CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = + new CommandParameterInfo("arg2", Integer.class); + testClustertestEnumsRequestCommandParams.put( + "arg2", testClustertestEnumsRequestarg2CommandParameterInfo); + + InteractionInfo testClustertestEnumsRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testEnumsRequest( + (ChipClusters.TestClusterCluster.TestEnumsResponseCallback) callback, + (Integer) commandArguments.get("arg1"), + (Integer) commandArguments.get("arg2")); + }, + () -> new DelegatedTestEnumsResponseCallback(), + testClustertestEnumsRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testEnumsRequest", testClustertestEnumsRequestInteractionInfo); + Map testClustertestListInt8UArgumentRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", ArrayList.class); + testClustertestListInt8UArgumentRequestCommandParams.put( + "arg1", testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListInt8UArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ArrayList) commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListInt8UArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestInteractionInfo); + Map testClustertestListInt8UReverseRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", ArrayList.class); + testClustertestListInt8UReverseRequestCommandParams.put( + "arg1", testClustertestListInt8UReverseRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListInt8UReverseRequest( + (ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) + callback, + (ArrayList) commandArguments.get("arg1")); + }, + () -> new DelegatedTestListInt8UReverseResponseCallback(), + testClustertestListInt8UReverseRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListInt8UReverseRequest", testClustertestListInt8UReverseRequestInteractionInfo); + Map + testClustertestListNestedStructListArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestListNestedStructListArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListNestedStructListArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ArrayList) + commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListNestedStructListArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListNestedStructListArgumentRequest", + testClustertestListNestedStructListArgumentRequestInteractionInfo); + Map testClustertestListStructArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListStructArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ArrayList) + commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListStructArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListStructArgumentRequest", testClustertestListStructArgumentRequestInteractionInfo); + Map testClustertestNestedStructArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestNestedStructArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNestedStructArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ChipStructs.TestClusterClusterNestedStruct) commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestNestedStructArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNestedStructArgumentRequest", + testClustertestNestedStructArgumentRequestInteractionInfo); + Map testClustertestNestedStructListArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestNestedStructListArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNestedStructListArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ChipStructs.TestClusterClusterNestedStructList) + commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestNestedStructListArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNestedStructListArgumentRequest", + testClustertestNestedStructListArgumentRequestInteractionInfo); + Map testClustertestNotHandledCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestNotHandledInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNotHandled((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestNotHandledCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNotHandled", testClustertestNotHandledInteractionInfo); + Map testClustertestNullableOptionalRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Optional.class); + testClustertestNullableOptionalRequestCommandParams.put( + "arg1", testClustertestNullableOptionalRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNullableOptionalRequest( + (ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) + callback, + (Optional) commandArguments.get("arg1")); + }, + () -> new DelegatedTestNullableOptionalResponseCallback(), + testClustertestNullableOptionalRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNullableOptionalRequest", testClustertestNullableOptionalRequestInteractionInfo); + Map testClustertestSimpleOptionalArgumentRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Optional.class); + testClustertestSimpleOptionalArgumentRequestCommandParams.put( + "arg1", testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testSimpleOptionalArgumentRequest( + (DefaultClusterCallback) callback, + (Optional) commandArguments.get("arg1")); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestSimpleOptionalArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testSimpleOptionalArgumentRequest", + testClustertestSimpleOptionalArgumentRequestInteractionInfo); + Map testClustertestSpecificCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestSpecificInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testSpecific( + (ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback); + }, + () -> new DelegatedTestSpecificResponseCallback(), + testClustertestSpecificCommandParams); + testClusterClusterInteractionInfoMap.put( + "testSpecific", testClustertestSpecificInteractionInfo); + Map testClustertestStructArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestStructArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testStructArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestStructArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testStructArgumentRequest", testClustertestStructArgumentRequestInteractionInfo); + Map testClustertestUnknownCommandCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestUnknownCommandInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testUnknownCommand((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestUnknownCommandCommandParams); + testClusterClusterInteractionInfoMap.put( + "testUnknownCommand", testClustertestUnknownCommandInteractionInfo); + Map testClustertimedInvokeRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertimedInvokeRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .timedInvokeRequest((DefaultClusterCallback) callback, 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertimedInvokeRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "timedInvokeRequest", testClustertimedInvokeRequestInteractionInfo); + commandMap.put("testCluster", testClusterClusterInteractionInfoMap); + Map thermostatClusterInteractionInfoMap = new LinkedHashMap<>(); + Map thermostatclearWeeklyScheduleCommandParams = + new LinkedHashMap(); + InteractionInfo thermostatclearWeeklyScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .clearWeeklySchedule((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatclearWeeklyScheduleCommandParams); + thermostatClusterInteractionInfoMap.put( + "clearWeeklySchedule", thermostatclearWeeklyScheduleInteractionInfo); + Map thermostatgetRelayStatusLogCommandParams = + new LinkedHashMap(); + InteractionInfo thermostatgetRelayStatusLogInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .getRelayStatusLog( + (ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback); + }, + () -> new DelegatedGetRelayStatusLogResponseCallback(), + thermostatgetRelayStatusLogCommandParams); + thermostatClusterInteractionInfoMap.put( + "getRelayStatusLog", thermostatgetRelayStatusLogInteractionInfo); + Map thermostatgetWeeklyScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = + new CommandParameterInfo("daysToReturn", Integer.class); + thermostatgetWeeklyScheduleCommandParams.put( + "daysToReturn", thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); + + CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = + new CommandParameterInfo("modeToReturn", Integer.class); + thermostatgetWeeklyScheduleCommandParams.put( + "modeToReturn", thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); + + InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .getWeeklySchedule( + (ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback) callback, + (Integer) commandArguments.get("daysToReturn"), + (Integer) commandArguments.get("modeToReturn")); + }, + () -> new DelegatedGetWeeklyScheduleResponseCallback(), + thermostatgetWeeklyScheduleCommandParams); + thermostatClusterInteractionInfoMap.put( + "getWeeklySchedule", thermostatgetWeeklyScheduleInteractionInfo); + Map thermostatsetWeeklyScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo + thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = + new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put( + "numberOfTransitionsForSequence", + thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = + new CommandParameterInfo("dayOfWeekForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put( + "dayOfWeekForSequence", + thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = + new CommandParameterInfo("modeForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put( + "modeForSequence", thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = + new CommandParameterInfo("payload", ArrayList.class); + thermostatsetWeeklyScheduleCommandParams.put( + "payload", thermostatsetWeeklySchedulepayloadCommandParameterInfo); + + InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .setWeeklySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("numberOfTransitionsForSequence"), + (Integer) commandArguments.get("dayOfWeekForSequence"), + (Integer) commandArguments.get("modeForSequence"), + (ArrayList) commandArguments.get("payload")); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatsetWeeklyScheduleCommandParams); + thermostatClusterInteractionInfoMap.put( + "setWeeklySchedule", thermostatsetWeeklyScheduleInteractionInfo); + Map thermostatsetpointRaiseLowerCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = + new CommandParameterInfo("mode", Integer.class); + thermostatsetpointRaiseLowerCommandParams.put( + "mode", thermostatsetpointRaiseLowermodeCommandParameterInfo); + + CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = + new CommandParameterInfo("amount", Integer.class); + thermostatsetpointRaiseLowerCommandParams.put( + "amount", thermostatsetpointRaiseLoweramountCommandParameterInfo); + + InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .setpointRaiseLower( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("mode"), + (Integer) commandArguments.get("amount")); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatsetpointRaiseLowerCommandParams); + thermostatClusterInteractionInfoMap.put( + "setpointRaiseLower", thermostatsetpointRaiseLowerInteractionInfo); + commandMap.put("thermostat", thermostatClusterInteractionInfoMap); + Map thermostatUserInterfaceConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put( + "thermostatUserInterfaceConfiguration", + thermostatUserInterfaceConfigurationClusterInteractionInfoMap); + Map threadNetworkDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map threadNetworkDiagnosticsresetCountsCommandParams = + new LinkedHashMap(); + InteractionInfo threadNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + threadNetworkDiagnosticsresetCountsCommandParams); + threadNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", threadNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInteractionInfoMap); + Map timeFormatLocalizationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("timeFormatLocalization", timeFormatLocalizationClusterInteractionInfoMap); + Map unitLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("unitLocalization", unitLocalizationClusterInteractionInfoMap); + Map userLabelClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("userLabel", userLabelClusterInteractionInfoMap); + Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); + Map wiFiNetworkDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map wiFiNetworkDiagnosticsresetCountsCommandParams = + new LinkedHashMap(); + InteractionInfo wiFiNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + wiFiNetworkDiagnosticsresetCountsCommandParams); + wiFiNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", wiFiNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInteractionInfoMap); + Map windowCoveringClusterInteractionInfoMap = new LinkedHashMap<>(); + Map windowCoveringdownOrCloseCommandParams = + new LinkedHashMap(); + InteractionInfo windowCoveringdownOrCloseInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .downOrClose((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringdownOrCloseCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "downOrClose", windowCoveringdownOrCloseInteractionInfo); + Map windowCoveringgoToLiftPercentageCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = + new CommandParameterInfo("liftPercentageValue", Integer.class); + windowCoveringgoToLiftPercentageCommandParams.put( + "liftPercentageValue", + windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); + + CommandParameterInfo + windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = + new CommandParameterInfo("liftPercent100thsValue", Integer.class); + windowCoveringgoToLiftPercentageCommandParams.put( + "liftPercent100thsValue", + windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToLiftPercentage( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("liftPercentageValue"), + (Integer) commandArguments.get("liftPercent100thsValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToLiftPercentageCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToLiftPercentage", windowCoveringgoToLiftPercentageInteractionInfo); + Map windowCoveringgoToLiftValueCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = + new CommandParameterInfo("liftValue", Integer.class); + windowCoveringgoToLiftValueCommandParams.put( + "liftValue", windowCoveringgoToLiftValueliftValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToLiftValueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToLiftValue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("liftValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToLiftValueCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToLiftValue", windowCoveringgoToLiftValueInteractionInfo); + Map windowCoveringgoToTiltPercentageCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = + new CommandParameterInfo("tiltPercentageValue", Integer.class); + windowCoveringgoToTiltPercentageCommandParams.put( + "tiltPercentageValue", + windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); + + CommandParameterInfo + windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = + new CommandParameterInfo("tiltPercent100thsValue", Integer.class); + windowCoveringgoToTiltPercentageCommandParams.put( + "tiltPercent100thsValue", + windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToTiltPercentage( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("tiltPercentageValue"), + (Integer) commandArguments.get("tiltPercent100thsValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToTiltPercentageCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToTiltPercentage", windowCoveringgoToTiltPercentageInteractionInfo); + Map windowCoveringgoToTiltValueCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = + new CommandParameterInfo("tiltValue", Integer.class); + windowCoveringgoToTiltValueCommandParams.put( + "tiltValue", windowCoveringgoToTiltValuetiltValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToTiltValueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToTiltValue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("tiltValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToTiltValueCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToTiltValue", windowCoveringgoToTiltValueInteractionInfo); + Map windowCoveringstopMotionCommandParams = + new LinkedHashMap(); + InteractionInfo windowCoveringstopMotionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .stopMotion((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringstopMotionCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "stopMotion", windowCoveringstopMotionInteractionInfo); + Map windowCoveringupOrOpenCommandParams = + new LinkedHashMap(); + InteractionInfo windowCoveringupOrOpenInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .upOrOpen((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringupOrOpenCommandParams); + windowCoveringClusterInteractionInfoMap.put("upOrOpen", windowCoveringupOrOpenInteractionInfo); + commandMap.put("windowCovering", windowCoveringClusterInteractionInfoMap); + return commandMap; + } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java index e433d2ce7db37d..2dc210109c6a96 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java @@ -29,8044 +29,8466 @@ public class ClusterReadMapping { public Map> getReadAttributeMap() { Map> readAttributeMap = new HashMap<>(); - Map readAccessControlInteractionInfo = new LinkedHashMap<>(); - Map readAccessControlAclCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlAclAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readAclAttribute( - ( ChipClusters.AccessControlCluster.AclAttributeCallback - ) callback - ); - }, + Map readAccessControlInteractionInfo = 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 - ); - readAccessControlInteractionInfo.put("readAclAttribute", readAccessControlAclAttributeInteractionInfo); - Map readAccessControlExtensionCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlExtensionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readExtensionAttribute( - ( ChipClusters.AccessControlCluster.ExtensionAttributeCallback - ) callback - ); - }, + readAccessControlAclCommandParams); + readAccessControlInteractionInfo.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 - ); - readAccessControlInteractionInfo.put("readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); - Map readAccessControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AccessControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterAttributeListAttributeCallback(), - readAccessControlAttributeListCommandParams - ); - readAccessControlInteractionInfo.put("readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); - Map readAccessControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlClusterRevisionCommandParams - ); - readAccessControlInteractionInfo.put("readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("accessControl", readAccessControlInteractionInfo); - Map readAccountLoginInteractionInfo = new LinkedHashMap<>(); - Map readAccountLoginAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AccountLoginCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), - readAccountLoginAttributeListCommandParams - ); - readAccountLoginInteractionInfo.put("readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); - Map readAccountLoginClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccountLoginClusterRevisionCommandParams - ); - readAccountLoginInteractionInfo.put("readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("accountLogin", readAccountLoginInteractionInfo); - Map readAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readAdministratorCommissioningWindowStatusCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readWindowStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningWindowStatusCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readWindowStatusAttribute", readAdministratorCommissioningWindowStatusAttributeInteractionInfo); - Map readAdministratorCommissioningAdminFabricIndexCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminFabricIndexAttribute( - ( ChipClusters.AdministratorCommissioningCluster.AdminFabricIndexAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningAdminFabricIndexCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readAdminFabricIndexAttribute", readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); - Map readAdministratorCommissioningAdminVendorIdCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminVendorIdAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningAdminVendorIdCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readAdminVendorIdAttribute", readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); - Map readAdministratorCommissioningAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AdministratorCommissioningCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), - readAdministratorCommissioningAttributeListCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readAttributeListAttribute", readAdministratorCommissioningAttributeListAttributeInteractionInfo); - Map readAdministratorCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningClusterRevisionCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readClusterRevisionAttribute", readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("administratorCommissioning", readAdministratorCommissioningInteractionInfo); - Map readApplicationBasicInteractionInfo = new LinkedHashMap<>(); - Map readApplicationBasicVendorNameCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readVendorNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readAccessControlExtensionCommandParams); + readAccessControlInteractionInfo.put( + "readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); + Map readAccessControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AccessControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAccessControlClusterAttributeListAttributeCallback(), + readAccessControlAttributeListCommandParams); + readAccessControlInteractionInfo.put( + "readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); + Map readAccessControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlClusterRevisionCommandParams); + readAccessControlInteractionInfo.put( + "readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("accessControl", readAccessControlInteractionInfo); + Map readAccountLoginInteractionInfo = new LinkedHashMap<>(); + Map readAccountLoginAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AccountLoginCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), + readAccountLoginAttributeListCommandParams); + readAccountLoginInteractionInfo.put( + "readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); + Map readAccountLoginClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccountLoginClusterRevisionCommandParams); + readAccountLoginInteractionInfo.put( + "readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("accountLogin", readAccountLoginInteractionInfo); + Map readAdministratorCommissioningInteractionInfo = + new LinkedHashMap<>(); + Map readAdministratorCommissioningWindowStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readWindowStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningWindowStatusCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readWindowStatusAttribute", + readAdministratorCommissioningWindowStatusAttributeInteractionInfo); + Map readAdministratorCommissioningAdminFabricIndexCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAdminFabricIndexAttribute( + (ChipClusters.AdministratorCommissioningCluster + .AdminFabricIndexAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningAdminFabricIndexCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readAdminFabricIndexAttribute", + readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); + Map readAdministratorCommissioningAdminVendorIdCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAdminVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningAdminVendorIdCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readAdminVendorIdAttribute", + readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); + Map readAdministratorCommissioningAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AdministratorCommissioningCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), + readAdministratorCommissioningAttributeListCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readAttributeListAttribute", + readAdministratorCommissioningAttributeListAttributeInteractionInfo); + Map readAdministratorCommissioningClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningClusterRevisionCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readClusterRevisionAttribute", + readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "administratorCommissioning", readAdministratorCommissioningInteractionInfo); + Map readApplicationBasicInteractionInfo = new LinkedHashMap<>(); + Map readApplicationBasicVendorNameCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicVendorNameCommandParams - ); - readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.put("readVendorIdAttribute", readApplicationBasicVendorIdAttributeInteractionInfo); - Map readApplicationBasicApplicationNameCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readApplicationBasicVendorNameCommandParams); + readApplicationBasicInteractionInfo.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); + readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.put("readProductIdAttribute", readApplicationBasicProductIdAttributeInteractionInfo); - Map readApplicationBasicApplicationStatusCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicApplicationStatusCommandParams - ); - readApplicationBasicInteractionInfo.put("readApplicationStatusAttribute", readApplicationBasicApplicationStatusAttributeInteractionInfo); - Map readApplicationBasicApplicationVersionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationVersionAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readApplicationBasicApplicationNameCommandParams); + readApplicationBasicInteractionInfo.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); + readApplicationBasicInteractionInfo.put( + "readProductIdAttribute", readApplicationBasicProductIdAttributeInteractionInfo); + Map readApplicationBasicApplicationStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readApplicationStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicApplicationStatusCommandParams); + readApplicationBasicInteractionInfo.put( + "readApplicationStatusAttribute", + readApplicationBasicApplicationStatusAttributeInteractionInfo); + Map readApplicationBasicApplicationVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readApplicationVersionAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicApplicationVersionCommandParams - ); - readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.put("readAllowedVendorListAttribute", readApplicationBasicAllowedVendorListAttributeInteractionInfo); - Map readApplicationBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterAttributeListAttributeCallback(), - readApplicationBasicAttributeListCommandParams - ); - readApplicationBasicInteractionInfo.put("readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); - Map readApplicationBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicClusterRevisionCommandParams - ); - readApplicationBasicInteractionInfo.put("readClusterRevisionAttribute", readApplicationBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("applicationBasic", readApplicationBasicInteractionInfo); - Map readApplicationLauncherInteractionInfo = new LinkedHashMap<>(); - Map readApplicationLauncherApplicationLauncherListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherApplicationLauncherListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readApplicationLauncherListAttribute( - ( ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback(), - readApplicationLauncherApplicationLauncherListCommandParams - ); - readApplicationLauncherInteractionInfo.put("readApplicationLauncherListAttribute", readApplicationLauncherApplicationLauncherListAttributeInteractionInfo); - Map readApplicationLauncherAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), - readApplicationLauncherAttributeListCommandParams - ); - readApplicationLauncherInteractionInfo.put("readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); - Map readApplicationLauncherClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationLauncherClusterRevisionCommandParams - ); - readApplicationLauncherInteractionInfo.put("readClusterRevisionAttribute", readApplicationLauncherClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("applicationLauncher", readApplicationLauncherInteractionInfo); - Map readAudioOutputInteractionInfo = new LinkedHashMap<>(); - Map readAudioOutputAudioOutputListCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputAudioOutputListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readAudioOutputListAttribute( - ( ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAudioOutputListAttributeCallback(), - readAudioOutputAudioOutputListCommandParams - ); - readAudioOutputInteractionInfo.put("readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeInteractionInfo); - Map readAudioOutputCurrentAudioOutputCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputCurrentAudioOutputAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readCurrentAudioOutputAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputCurrentAudioOutputCommandParams - ); - readAudioOutputInteractionInfo.put("readCurrentAudioOutputAttribute", readAudioOutputCurrentAudioOutputAttributeInteractionInfo); - Map readAudioOutputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AudioOutputCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), - readAudioOutputAttributeListCommandParams - ); - readAudioOutputInteractionInfo.put("readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); - Map readAudioOutputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputClusterRevisionCommandParams - ); - readAudioOutputInteractionInfo.put("readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("audioOutput", readAudioOutputInteractionInfo); - Map readBarrierControlInteractionInfo = new LinkedHashMap<>(); - Map readBarrierControlBarrierMovingStateCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierMovingStateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierMovingStateCommandParams - ); - readBarrierControlInteractionInfo.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 - ); - readBarrierControlInteractionInfo.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 - ); - readBarrierControlInteractionInfo.put("readBarrierCapabilitiesAttribute", readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); - Map readBarrierControlBarrierPositionCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierPositionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierPositionCommandParams - ); - readBarrierControlInteractionInfo.put("readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); - Map readBarrierControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BarrierControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBarrierControlClusterAttributeListAttributeCallback(), - readBarrierControlAttributeListCommandParams - ); - readBarrierControlInteractionInfo.put("readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); - Map readBarrierControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlClusterRevisionCommandParams - ); - readBarrierControlInteractionInfo.put("readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("barrierControl", readBarrierControlInteractionInfo); - Map readBasicInteractionInfo = new LinkedHashMap<>(); - Map readBasicInteractionModelVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInteractionModelVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readInteractionModelVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInteractionModelVersionCommandParams - ); - readBasicInteractionInfo.put("readInteractionModelVersionAttribute", readBasicInteractionModelVersionAttributeInteractionInfo); - Map readBasicVendorNameCommandParams = new LinkedHashMap(); - InteractionInfo readBasicVendorNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readVendorNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readApplicationBasicApplicationVersionCommandParams); + readApplicationBasicInteractionInfo.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); + readApplicationBasicInteractionInfo.put( + "readAllowedVendorListAttribute", + readApplicationBasicAllowedVendorListAttributeInteractionInfo); + Map readApplicationBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationBasicClusterAttributeListAttributeCallback(), + readApplicationBasicAttributeListCommandParams); + readApplicationBasicInteractionInfo.put( + "readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); + Map readApplicationBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicClusterRevisionCommandParams); + readApplicationBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readApplicationBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationBasic", readApplicationBasicInteractionInfo); + Map readApplicationLauncherInteractionInfo = new LinkedHashMap<>(); + Map readApplicationLauncherApplicationLauncherListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherApplicationLauncherListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readApplicationLauncherListAttribute( + (ChipClusters.ApplicationLauncherCluster + .ApplicationLauncherListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback(), + readApplicationLauncherApplicationLauncherListCommandParams); + readApplicationLauncherInteractionInfo.put( + "readApplicationLauncherListAttribute", + readApplicationLauncherApplicationLauncherListAttributeInteractionInfo); + Map readApplicationLauncherAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), + readApplicationLauncherAttributeListCommandParams); + readApplicationLauncherInteractionInfo.put( + "readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); + Map readApplicationLauncherClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationLauncherClusterRevisionCommandParams); + readApplicationLauncherInteractionInfo.put( + "readClusterRevisionAttribute", + readApplicationLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationLauncher", readApplicationLauncherInteractionInfo); + Map readAudioOutputInteractionInfo = new LinkedHashMap<>(); + Map readAudioOutputAudioOutputListCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputAudioOutputListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readAudioOutputListAttribute( + (ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAudioOutputClusterAudioOutputListAttributeCallback(), + readAudioOutputAudioOutputListCommandParams); + readAudioOutputInteractionInfo.put( + "readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeInteractionInfo); + Map readAudioOutputCurrentAudioOutputCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputCurrentAudioOutputAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readCurrentAudioOutputAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputCurrentAudioOutputCommandParams); + readAudioOutputInteractionInfo.put( + "readCurrentAudioOutputAttribute", + readAudioOutputCurrentAudioOutputAttributeInteractionInfo); + Map readAudioOutputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AudioOutputCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), + readAudioOutputAttributeListCommandParams); + readAudioOutputInteractionInfo.put( + "readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); + Map readAudioOutputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputClusterRevisionCommandParams); + readAudioOutputInteractionInfo.put( + "readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("audioOutput", readAudioOutputInteractionInfo); + Map readBarrierControlInteractionInfo = new LinkedHashMap<>(); + Map readBarrierControlBarrierMovingStateCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierMovingStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierMovingStateCommandParams); + readBarrierControlInteractionInfo.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); + readBarrierControlInteractionInfo.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); + readBarrierControlInteractionInfo.put( + "readBarrierCapabilitiesAttribute", + readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); + Map readBarrierControlBarrierPositionCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierPositionCommandParams); + readBarrierControlInteractionInfo.put( + "readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); + Map readBarrierControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BarrierControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBarrierControlClusterAttributeListAttributeCallback(), + readBarrierControlAttributeListCommandParams); + readBarrierControlInteractionInfo.put( + "readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); + Map readBarrierControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlClusterRevisionCommandParams); + readBarrierControlInteractionInfo.put( + "readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("barrierControl", readBarrierControlInteractionInfo); + Map readBasicInteractionInfo = new LinkedHashMap<>(); + Map readBasicInteractionModelVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInteractionModelVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readInteractionModelVersionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInteractionModelVersionCommandParams); + readBasicInteractionInfo.put( + "readInteractionModelVersionAttribute", + readBasicInteractionModelVersionAttributeInteractionInfo); + Map readBasicVendorNameCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicVendorNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicVendorNameCommandParams - ); - readBasicInteractionInfo.put("readVendorNameAttribute", readBasicVendorNameAttributeInteractionInfo); - Map readBasicVendorIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicVendorIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readVendorIDAttribute( - ( ChipClusters.BasicCluster.VendorIDAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicVendorIDCommandParams - ); - readBasicInteractionInfo.put("readVendorIDAttribute", readBasicVendorIDAttributeInteractionInfo); - Map readBasicProductNameCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicVendorNameCommandParams); + readBasicInteractionInfo.put( + "readVendorNameAttribute", readBasicVendorNameAttributeInteractionInfo); + Map readBasicVendorIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicVendorIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readVendorIDAttribute( + (ChipClusters.BasicCluster.VendorIDAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicVendorIDCommandParams); + readBasicInteractionInfo.put( + "readVendorIDAttribute", readBasicVendorIDAttributeInteractionInfo); + Map readBasicProductNameCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductNameCommandParams - ); - readBasicInteractionInfo.put("readProductNameAttribute", readBasicProductNameAttributeInteractionInfo); - Map readBasicProductIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductIDAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicProductIDCommandParams - ); - readBasicInteractionInfo.put("readProductIDAttribute", readBasicProductIDAttributeInteractionInfo); - Map readBasicNodeLabelCommandParams = new LinkedHashMap(); - InteractionInfo readBasicNodeLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readNodeLabelAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicProductNameCommandParams); + readBasicInteractionInfo.put( + "readProductNameAttribute", readBasicProductNameAttributeInteractionInfo); + Map readBasicProductIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductIDAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicProductIDCommandParams); + readBasicInteractionInfo.put( + "readProductIDAttribute", readBasicProductIDAttributeInteractionInfo); + Map readBasicNodeLabelCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicNodeLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readNodeLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicNodeLabelCommandParams - ); - readBasicInteractionInfo.put("readNodeLabelAttribute", readBasicNodeLabelAttributeInteractionInfo); - Map readBasicLocationCommandParams = new LinkedHashMap(); - InteractionInfo readBasicLocationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readLocationAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicNodeLabelCommandParams); + readBasicInteractionInfo.put( + "readNodeLabelAttribute", readBasicNodeLabelAttributeInteractionInfo); + Map readBasicLocationCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicLocationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readLocationAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicLocationCommandParams - ); - readBasicInteractionInfo.put("readLocationAttribute", readBasicLocationAttributeInteractionInfo); - Map readBasicHardwareVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicHardwareVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readHardwareVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicHardwareVersionCommandParams - ); - readBasicInteractionInfo.put("readHardwareVersionAttribute", readBasicHardwareVersionAttributeInteractionInfo); - Map readBasicHardwareVersionStringCommandParams = new LinkedHashMap(); - InteractionInfo readBasicHardwareVersionStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readHardwareVersionStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicLocationCommandParams); + readBasicInteractionInfo.put( + "readLocationAttribute", readBasicLocationAttributeInteractionInfo); + Map readBasicHardwareVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicHardwareVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readHardwareVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicHardwareVersionCommandParams); + readBasicInteractionInfo.put( + "readHardwareVersionAttribute", readBasicHardwareVersionAttributeInteractionInfo); + Map readBasicHardwareVersionStringCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicHardwareVersionStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readHardwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicHardwareVersionStringCommandParams - ); - readBasicInteractionInfo.put("readHardwareVersionStringAttribute", readBasicHardwareVersionStringAttributeInteractionInfo); - Map readBasicSoftwareVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicSoftwareVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readSoftwareVersionAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readBasicHardwareVersionStringCommandParams); + readBasicInteractionInfo.put( + "readHardwareVersionStringAttribute", + readBasicHardwareVersionStringAttributeInteractionInfo); + Map readBasicSoftwareVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicSoftwareVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readSoftwareVersionAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBasicSoftwareVersionCommandParams - ); - readBasicInteractionInfo.put("readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeInteractionInfo); - Map readBasicSoftwareVersionStringCommandParams = new LinkedHashMap(); - InteractionInfo readBasicSoftwareVersionStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readSoftwareVersionStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicSoftwareVersionCommandParams); + readBasicInteractionInfo.put( + "readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeInteractionInfo); + Map readBasicSoftwareVersionStringCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicSoftwareVersionStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readSoftwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicSoftwareVersionStringCommandParams - ); - readBasicInteractionInfo.put("readSoftwareVersionStringAttribute", readBasicSoftwareVersionStringAttributeInteractionInfo); - Map readBasicManufacturingDateCommandParams = new LinkedHashMap(); - InteractionInfo readBasicManufacturingDateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readManufacturingDateAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicSoftwareVersionStringCommandParams); + readBasicInteractionInfo.put( + "readSoftwareVersionStringAttribute", + readBasicSoftwareVersionStringAttributeInteractionInfo); + Map readBasicManufacturingDateCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicManufacturingDateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readManufacturingDateAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicManufacturingDateCommandParams - ); - readBasicInteractionInfo.put("readManufacturingDateAttribute", readBasicManufacturingDateAttributeInteractionInfo); - Map readBasicPartNumberCommandParams = new LinkedHashMap(); - InteractionInfo readBasicPartNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readPartNumberAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicManufacturingDateCommandParams); + readBasicInteractionInfo.put( + "readManufacturingDateAttribute", readBasicManufacturingDateAttributeInteractionInfo); + Map readBasicPartNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicPartNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readPartNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicPartNumberCommandParams - ); - readBasicInteractionInfo.put("readPartNumberAttribute", readBasicPartNumberAttributeInteractionInfo); - Map readBasicProductURLCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductURLAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductURLAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicPartNumberCommandParams); + readBasicInteractionInfo.put( + "readPartNumberAttribute", readBasicPartNumberAttributeInteractionInfo); + Map readBasicProductURLCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductURLAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductURLAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductURLCommandParams - ); - readBasicInteractionInfo.put("readProductURLAttribute", readBasicProductURLAttributeInteractionInfo); - Map readBasicProductLabelCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductLabelAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicProductURLCommandParams); + readBasicInteractionInfo.put( + "readProductURLAttribute", readBasicProductURLAttributeInteractionInfo); + Map readBasicProductLabelCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductLabelCommandParams - ); - readBasicInteractionInfo.put("readProductLabelAttribute", readBasicProductLabelAttributeInteractionInfo); - Map readBasicSerialNumberCommandParams = new LinkedHashMap(); - InteractionInfo readBasicSerialNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readSerialNumberAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicProductLabelCommandParams); + readBasicInteractionInfo.put( + "readProductLabelAttribute", readBasicProductLabelAttributeInteractionInfo); + Map readBasicSerialNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicSerialNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readSerialNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicSerialNumberCommandParams - ); - readBasicInteractionInfo.put("readSerialNumberAttribute", readBasicSerialNumberAttributeInteractionInfo); - Map readBasicLocalConfigDisabledCommandParams = new LinkedHashMap(); - InteractionInfo readBasicLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readLocalConfigDisabledAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBasicSerialNumberCommandParams); + readBasicInteractionInfo.put( + "readSerialNumberAttribute", readBasicSerialNumberAttributeInteractionInfo); + Map readBasicLocalConfigDisabledCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicLocalConfigDisabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readLocalConfigDisabledAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicLocalConfigDisabledCommandParams - ); - readBasicInteractionInfo.put("readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeInteractionInfo); - Map readBasicReachableCommandParams = new LinkedHashMap(); - InteractionInfo readBasicReachableAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readReachableAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBasicLocalConfigDisabledCommandParams); + readBasicInteractionInfo.put( + "readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeInteractionInfo); + Map readBasicReachableCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicReachableAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readReachableAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicReachableCommandParams - ); - readBasicInteractionInfo.put("readReachableAttribute", readBasicReachableAttributeInteractionInfo); - Map readBasicUniqueIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicUniqueIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readUniqueIDAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicReachableCommandParams); + readBasicInteractionInfo.put( + "readReachableAttribute", readBasicReachableAttributeInteractionInfo); + Map readBasicUniqueIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicUniqueIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readUniqueIDAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicUniqueIDCommandParams - ); - readBasicInteractionInfo.put("readUniqueIDAttribute", readBasicUniqueIDAttributeInteractionInfo); - Map readBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BasicCluster.AttributeListAttributeCallback - ) callback - ); - }, + readBasicUniqueIDCommandParams); + readBasicInteractionInfo.put( + "readUniqueIDAttribute", readBasicUniqueIDAttributeInteractionInfo); + Map readBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BasicCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBasicClusterAttributeListAttributeCallback(), - readBasicAttributeListCommandParams - ); - readBasicInteractionInfo.put("readAttributeListAttribute", readBasicAttributeListAttributeInteractionInfo); - Map readBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicClusterRevisionCommandParams - ); - readBasicInteractionInfo.put("readClusterRevisionAttribute", readBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("basic", readBasicInteractionInfo); - Map readBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map readBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readOutOfServiceAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBasicAttributeListCommandParams); + readBasicInteractionInfo.put( + "readAttributeListAttribute", readBasicAttributeListAttributeInteractionInfo); + Map readBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicClusterRevisionCommandParams); + readBasicInteractionInfo.put( + "readClusterRevisionAttribute", readBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("basic", readBasicInteractionInfo); + Map readBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); + Map readBinaryInputBasicOutOfServiceCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readOutOfServiceAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicOutOfServiceCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); - Map readBinaryInputBasicPresentValueCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readPresentValueAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBinaryInputBasicOutOfServiceCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); + Map readBinaryInputBasicPresentValueCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readPresentValueAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicPresentValueCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); - Map readBinaryInputBasicStatusFlagsCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readStatusFlagsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicStatusFlagsCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); - Map readBinaryInputBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), - readBinaryInputBasicAttributeListCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); - Map readBinaryInputBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicClusterRevisionCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readClusterRevisionAttribute", readBinaryInputBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("binaryInputBasic", readBinaryInputBasicInteractionInfo); - Map readBindingInteractionInfo = new LinkedHashMap<>(); - Map readBindingAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBindingAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BindingCluster.AttributeListAttributeCallback - ) callback - ); - }, + readBinaryInputBasicPresentValueCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); + Map readBinaryInputBasicStatusFlagsCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readStatusFlagsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicStatusFlagsCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); + Map readBinaryInputBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), + readBinaryInputBasicAttributeListCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); + Map readBinaryInputBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicClusterRevisionCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readBinaryInputBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binaryInputBasic", readBinaryInputBasicInteractionInfo); + Map readBindingInteractionInfo = new LinkedHashMap<>(); + Map readBindingAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BindingCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBindingClusterAttributeListAttributeCallback(), - readBindingAttributeListCommandParams - ); - readBindingInteractionInfo.put("readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); - Map readBindingClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBindingClusterRevisionCommandParams - ); - readBindingInteractionInfo.put("readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("binding", readBindingInteractionInfo); - Map readBooleanStateInteractionInfo = new LinkedHashMap<>(); - Map readBooleanStateStateValueCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readStateValueAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBindingAttributeListCommandParams); + readBindingInteractionInfo.put( + "readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); + Map readBindingClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBindingClusterRevisionCommandParams); + readBindingInteractionInfo.put( + "readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binding", readBindingInteractionInfo); + Map readBooleanStateInteractionInfo = new LinkedHashMap<>(); + Map readBooleanStateStateValueCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readStateValueAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBooleanStateStateValueCommandParams - ); - readBooleanStateInteractionInfo.put("readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); - Map readBooleanStateAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BooleanStateCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), - readBooleanStateAttributeListCommandParams - ); - readBooleanStateInteractionInfo.put("readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); - Map readBooleanStateClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBooleanStateClusterRevisionCommandParams - ); - readBooleanStateInteractionInfo.put("readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("booleanState", readBooleanStateInteractionInfo); - Map readBridgedActionsInteractionInfo = new LinkedHashMap<>(); - Map readBridgedActionsActionListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsActionListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readActionListAttribute( - ( ChipClusters.BridgedActionsCluster.ActionListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterActionListAttributeCallback(), - readBridgedActionsActionListCommandParams - ); - readBridgedActionsInteractionInfo.put("readActionListAttribute", readBridgedActionsActionListAttributeInteractionInfo); - Map readBridgedActionsEndpointListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsEndpointListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readEndpointListAttribute( - ( ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterEndpointListAttributeCallback(), - readBridgedActionsEndpointListCommandParams - ); - readBridgedActionsInteractionInfo.put("readEndpointListAttribute", readBridgedActionsEndpointListAttributeInteractionInfo); - Map readBridgedActionsSetupUrlCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsSetupUrlAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readSetupUrlAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBooleanStateStateValueCommandParams); + readBooleanStateInteractionInfo.put( + "readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); + Map readBooleanStateAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BooleanStateCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), + readBooleanStateAttributeListCommandParams); + readBooleanStateInteractionInfo.put( + "readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); + Map readBooleanStateClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanStateClusterRevisionCommandParams); + readBooleanStateInteractionInfo.put( + "readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("booleanState", readBooleanStateInteractionInfo); + Map readBridgedActionsInteractionInfo = new LinkedHashMap<>(); + Map readBridgedActionsActionListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsActionListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readActionListAttribute( + (ChipClusters.BridgedActionsCluster.ActionListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedBridgedActionsClusterActionListAttributeCallback(), + readBridgedActionsActionListCommandParams); + readBridgedActionsInteractionInfo.put( + "readActionListAttribute", readBridgedActionsActionListAttributeInteractionInfo); + Map readBridgedActionsEndpointListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsEndpointListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readEndpointListAttribute( + (ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedActionsClusterEndpointListAttributeCallback(), + readBridgedActionsEndpointListCommandParams); + readBridgedActionsInteractionInfo.put( + "readEndpointListAttribute", readBridgedActionsEndpointListAttributeInteractionInfo); + Map readBridgedActionsSetupUrlCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsSetupUrlAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readSetupUrlAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedActionsSetupUrlCommandParams - ); - readBridgedActionsInteractionInfo.put("readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeInteractionInfo); - Map readBridgedActionsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BridgedActionsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterAttributeListAttributeCallback(), - readBridgedActionsAttributeListCommandParams - ); - readBridgedActionsInteractionInfo.put("readAttributeListAttribute", readBridgedActionsAttributeListAttributeInteractionInfo); - Map readBridgedActionsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedActionsClusterRevisionCommandParams - ); - readBridgedActionsInteractionInfo.put("readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("bridgedActions", readBridgedActionsInteractionInfo); - Map readBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); - Map readBridgedDeviceBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BridgedDeviceBasicCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback(), - readBridgedDeviceBasicAttributeListCommandParams - ); - readBridgedDeviceBasicInteractionInfo.put("readAttributeListAttribute", readBridgedDeviceBasicAttributeListAttributeInteractionInfo); - Map readBridgedDeviceBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedDeviceBasicClusterRevisionCommandParams - ); - readBridgedDeviceBasicInteractionInfo.put("readClusterRevisionAttribute", readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("bridgedDeviceBasic", readBridgedDeviceBasicInteractionInfo); - Map readChannelInteractionInfo = new LinkedHashMap<>(); - Map readChannelChannelListCommandParams = new LinkedHashMap(); - InteractionInfo readChannelChannelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readChannelListAttribute( - ( ChipClusters.ChannelCluster.ChannelListAttributeCallback - ) callback - ); - }, + readBridgedActionsSetupUrlCommandParams); + readBridgedActionsInteractionInfo.put( + "readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeInteractionInfo); + Map readBridgedActionsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BridgedActionsCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedActionsClusterAttributeListAttributeCallback(), + readBridgedActionsAttributeListCommandParams); + readBridgedActionsInteractionInfo.put( + "readAttributeListAttribute", readBridgedActionsAttributeListAttributeInteractionInfo); + Map readBridgedActionsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedActionsClusterRevisionCommandParams); + readBridgedActionsInteractionInfo.put( + "readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedActions", readBridgedActionsInteractionInfo); + Map readBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); + Map readBridgedDeviceBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BridgedDeviceBasicCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback(), + readBridgedDeviceBasicAttributeListCommandParams); + readBridgedDeviceBasicInteractionInfo.put( + "readAttributeListAttribute", readBridgedDeviceBasicAttributeListAttributeInteractionInfo); + Map readBridgedDeviceBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedDeviceBasicClusterRevisionCommandParams); + readBridgedDeviceBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedDeviceBasic", readBridgedDeviceBasicInteractionInfo); + Map readChannelInteractionInfo = 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 - ); - readChannelInteractionInfo.put("readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); - Map readChannelAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readChannelAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ChannelCluster.AttributeListAttributeCallback - ) callback - ); - }, + readChannelChannelListCommandParams); + readChannelInteractionInfo.put( + "readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); + Map readChannelAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ChannelCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedChannelClusterAttributeListAttributeCallback(), - readChannelAttributeListCommandParams - ); - readChannelInteractionInfo.put("readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); - Map readChannelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readChannelClusterRevisionCommandParams - ); - readChannelInteractionInfo.put("readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("channel", readChannelInteractionInfo); - Map readColorControlInteractionInfo = new LinkedHashMap<>(); - Map readColorControlCurrentHueCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCurrentHueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentHueCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readDriftCompensationAttribute", readColorControlDriftCompensationAttributeInteractionInfo); - Map readColorControlCompensationTextCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCompensationTextAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCompensationTextAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readChannelAttributeListCommandParams); + readChannelInteractionInfo.put( + "readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); + Map readChannelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChannelClusterRevisionCommandParams); + readChannelInteractionInfo.put( + "readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("channel", readChannelInteractionInfo); + Map readColorControlInteractionInfo = new LinkedHashMap<>(); + Map readColorControlCurrentHueCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCurrentHueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentHueCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); - Map readColorControlColorTemperatureCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTemperatureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTemperatureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTemperatureCommandParams - ); - readColorControlInteractionInfo.put("readColorTemperatureAttribute", readColorControlColorTemperatureAttributeInteractionInfo); - Map readColorControlColorModeCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorModeCommandParams - ); - readColorControlInteractionInfo.put("readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); - Map readColorControlColorControlOptionsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorControlOptionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorControlOptionsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorControlOptionsCommandParams - ); - readColorControlInteractionInfo.put("readColorControlOptionsAttribute", readColorControlColorControlOptionsAttributeInteractionInfo); - Map readColorControlNumberOfPrimariesCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readNumberOfPrimariesAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlNumberOfPrimariesCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); - Map readColorControlPrimary1IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary1IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary1IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); - Map readColorControlPrimary2IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary2IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary2IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); - Map readColorControlPrimary3IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary3IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary3IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); - Map readColorControlPrimary4IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary4IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary4IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); - Map readColorControlPrimary5IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary5IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary5IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); - Map readColorControlPrimary6IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary6IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary6IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); - Map readColorControlColorPointRIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointRIntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointRIntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); - Map readColorControlColorPointGIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointGIntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointGIntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); - Map readColorControlColorPointBIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointBIntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointBIntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorCapabilitiesAttribute", readColorControlColorCapabilitiesAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMinCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMinAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMinCommandParams - ); - readColorControlInteractionInfo.put("readColorTempPhysicalMinAttribute", readColorControlColorTempPhysicalMinAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMaxCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMaxAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMaxCommandParams - ); - readColorControlInteractionInfo.put("readColorTempPhysicalMaxAttribute", readColorControlColorTempPhysicalMaxAttributeInteractionInfo); - Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCoupleColorTempToLevelMinMiredsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCoupleColorTempToLevelMinMiredsCommandParams - ); - readColorControlInteractionInfo.put("readCoupleColorTempToLevelMinMiredsAttribute", readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); - Map readColorControlStartUpColorTemperatureMiredsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readStartUpColorTemperatureMiredsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlStartUpColorTemperatureMiredsCommandParams - ); - readColorControlInteractionInfo.put("readStartUpColorTemperatureMiredsAttribute", readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); - Map readColorControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ColorControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), - readColorControlAttributeListCommandParams - ); - readColorControlInteractionInfo.put("readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); - Map readColorControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlClusterRevisionCommandParams - ); - readColorControlInteractionInfo.put("readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("colorControl", readColorControlInteractionInfo); - Map readContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map readContentLauncherAcceptHeaderListCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherAcceptHeaderListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readAcceptHeaderListAttribute( - ( ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback(), - readContentLauncherAcceptHeaderListCommandParams - ); - readContentLauncherInteractionInfo.put("readAcceptHeaderListAttribute", readContentLauncherAcceptHeaderListAttributeInteractionInfo); - Map readContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readSupportedStreamingProtocolsAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readColorControlCompensationTextCommandParams); + readColorControlInteractionInfo.put( + "readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); + Map readColorControlColorTemperatureCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTemperatureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTemperatureCommandParams); + readColorControlInteractionInfo.put( + "readColorTemperatureAttribute", readColorControlColorTemperatureAttributeInteractionInfo); + Map readColorControlColorModeCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorModeCommandParams); + readColorControlInteractionInfo.put( + "readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); + Map readColorControlColorControlOptionsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorControlOptionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorControlOptionsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorControlOptionsCommandParams); + readColorControlInteractionInfo.put( + "readColorControlOptionsAttribute", + readColorControlColorControlOptionsAttributeInteractionInfo); + Map readColorControlNumberOfPrimariesCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readNumberOfPrimariesAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlNumberOfPrimariesCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); + Map readColorControlPrimary1IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary1IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary1IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); + Map readColorControlPrimary2IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary2IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary2IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); + Map readColorControlPrimary3IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary3IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary3IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); + Map readColorControlPrimary4IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary4IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary4IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); + Map readColorControlPrimary5IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary5IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary5IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); + Map readColorControlPrimary6IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary6IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary6IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); + Map readColorControlColorPointRIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointRIntensityAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointRIntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); + Map readColorControlColorPointGIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointGIntensityAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointGIntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); + Map readColorControlColorPointBIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointBIntensityAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointBIntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorCapabilitiesAttribute", + readColorControlColorCapabilitiesAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMinCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTempPhysicalMinAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMinCommandParams); + readColorControlInteractionInfo.put( + "readColorTempPhysicalMinAttribute", + readColorControlColorTempPhysicalMinAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTempPhysicalMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMaxCommandParams); + readColorControlInteractionInfo.put( + "readColorTempPhysicalMaxAttribute", + readColorControlColorTempPhysicalMaxAttributeInteractionInfo); + Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCoupleColorTempToLevelMinMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCoupleColorTempToLevelMinMiredsCommandParams); + readColorControlInteractionInfo.put( + "readCoupleColorTempToLevelMinMiredsAttribute", + readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); + Map readColorControlStartUpColorTemperatureMiredsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readStartUpColorTemperatureMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlStartUpColorTemperatureMiredsCommandParams); + readColorControlInteractionInfo.put( + "readStartUpColorTemperatureMiredsAttribute", + readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); + Map readColorControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ColorControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), + readColorControlAttributeListCommandParams); + readColorControlInteractionInfo.put( + "readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); + Map readColorControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlClusterRevisionCommandParams); + readColorControlInteractionInfo.put( + "readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("colorControl", readColorControlInteractionInfo); + Map readContentLauncherInteractionInfo = new LinkedHashMap<>(); + Map readContentLauncherAcceptHeaderListCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherAcceptHeaderListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readAcceptHeaderListAttribute( + (ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback(), + readContentLauncherAcceptHeaderListCommandParams); + readContentLauncherInteractionInfo.put( + "readAcceptHeaderListAttribute", + readContentLauncherAcceptHeaderListAttributeInteractionInfo); + Map readContentLauncherSupportedStreamingProtocolsCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readSupportedStreamingProtocolsAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readContentLauncherSupportedStreamingProtocolsCommandParams - ); - readContentLauncherInteractionInfo.put("readSupportedStreamingProtocolsAttribute", readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); - Map readContentLauncherAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAttributeListAttributeCallback(), - readContentLauncherAttributeListCommandParams - ); - readContentLauncherInteractionInfo.put("readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); - Map readContentLauncherClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readContentLauncherClusterRevisionCommandParams - ); - readContentLauncherInteractionInfo.put("readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("contentLauncher", readContentLauncherInteractionInfo); - Map readDescriptorInteractionInfo = new LinkedHashMap<>(); - Map readDescriptorDeviceListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorDeviceListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readDeviceListAttribute( - ( ChipClusters.DescriptorCluster.DeviceListAttributeCallback - ) callback - ); - }, + readContentLauncherSupportedStreamingProtocolsCommandParams); + readContentLauncherInteractionInfo.put( + "readSupportedStreamingProtocolsAttribute", + readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); + Map readContentLauncherAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedContentLauncherClusterAttributeListAttributeCallback(), + readContentLauncherAttributeListCommandParams); + readContentLauncherInteractionInfo.put( + "readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); + Map readContentLauncherClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readContentLauncherClusterRevisionCommandParams); + readContentLauncherInteractionInfo.put( + "readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("contentLauncher", readContentLauncherInteractionInfo); + Map readDescriptorInteractionInfo = new LinkedHashMap<>(); + Map readDescriptorDeviceListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorDeviceListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readDeviceListAttribute( + (ChipClusters.DescriptorCluster.DeviceListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterDeviceListAttributeCallback(), - readDescriptorDeviceListCommandParams - ); - readDescriptorInteractionInfo.put("readDeviceListAttribute", readDescriptorDeviceListAttributeInteractionInfo); - Map readDescriptorServerListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorServerListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readServerListAttribute( - ( ChipClusters.DescriptorCluster.ServerListAttributeCallback - ) callback - ); - }, + readDescriptorDeviceListCommandParams); + readDescriptorInteractionInfo.put( + "readDeviceListAttribute", readDescriptorDeviceListAttributeInteractionInfo); + Map readDescriptorServerListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorServerListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readServerListAttribute( + (ChipClusters.DescriptorCluster.ServerListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterServerListAttributeCallback(), - readDescriptorServerListCommandParams - ); - readDescriptorInteractionInfo.put("readServerListAttribute", readDescriptorServerListAttributeInteractionInfo); - Map readDescriptorClientListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorClientListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readClientListAttribute( - ( ChipClusters.DescriptorCluster.ClientListAttributeCallback - ) callback - ); - }, + readDescriptorServerListCommandParams); + readDescriptorInteractionInfo.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 - ); - readDescriptorInteractionInfo.put("readClientListAttribute", readDescriptorClientListAttributeInteractionInfo); - Map readDescriptorPartsListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorPartsListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readPartsListAttribute( - ( ChipClusters.DescriptorCluster.PartsListAttributeCallback - ) callback - ); - }, + readDescriptorClientListCommandParams); + readDescriptorInteractionInfo.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 - ); - readDescriptorInteractionInfo.put("readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); - Map readDescriptorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readAttributeListAttribute( - ( ChipClusters.DescriptorCluster.AttributeListAttributeCallback - ) callback - ); - }, + readDescriptorPartsListCommandParams); + readDescriptorInteractionInfo.put( + "readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); + Map readDescriptorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DescriptorCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterAttributeListAttributeCallback(), - readDescriptorAttributeListCommandParams - ); - readDescriptorInteractionInfo.put("readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); - Map readDescriptorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDescriptorClusterRevisionCommandParams - ); - readDescriptorInteractionInfo.put("readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("descriptor", readDescriptorInteractionInfo); - Map readDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); - Map readDiagnosticLogsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), - readDiagnosticLogsAttributeListCommandParams - ); - readDiagnosticLogsInteractionInfo.put("readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); - readAttributeMap.put("diagnosticLogs", readDiagnosticLogsInteractionInfo); - Map readDoorLockInteractionInfo = new LinkedHashMap<>(); - Map readDoorLockLockStateCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockLockStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readLockStateAttribute( - ( ChipClusters.DoorLockCluster.LockStateAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockLockStateCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readLockTypeAttribute", readDoorLockLockTypeAttributeInteractionInfo); - Map readDoorLockActuatorEnabledCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockActuatorEnabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readActuatorEnabledAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readDescriptorAttributeListCommandParams); + readDescriptorInteractionInfo.put( + "readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); + Map readDescriptorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDescriptorClusterRevisionCommandParams); + readDescriptorInteractionInfo.put( + "readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("descriptor", readDescriptorInteractionInfo); + Map readDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); + Map readDiagnosticLogsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), + readDiagnosticLogsAttributeListCommandParams); + readDiagnosticLogsInteractionInfo.put( + "readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); + readAttributeMap.put("diagnosticLogs", readDiagnosticLogsInteractionInfo); + Map readDoorLockInteractionInfo = new LinkedHashMap<>(); + Map readDoorLockLockStateCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockLockStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readLockStateAttribute( + (ChipClusters.DoorLockCluster.LockStateAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockLockStateCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); - Map readDoorLockDoorStateCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readDoorStateAttribute( - ( ChipClusters.DoorLockCluster.DoorStateAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockDoorStateCommandParams - ); - readDoorLockInteractionInfo.put("readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); - Map readDoorLockNumberOfTotalUsersSupportedCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readNumberOfTotalUsersSupportedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfTotalUsersSupportedCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readNumberOfYearDaySchedulesSupportedPerUserAttribute", readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); - Map readDoorLockMaxPINCodeLengthCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readMaxPINCodeLengthAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMaxPINCodeLengthCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); - Map readDoorLockLanguageCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockLanguageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readLanguageAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readDoorLockActuatorEnabledCommandParams); + readDoorLockInteractionInfo.put( + "readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); + Map readDoorLockDoorStateCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readDoorStateAttribute( + (ChipClusters.DoorLockCluster.DoorStateAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockDoorStateCommandParams); + readDoorLockInteractionInfo.put( + "readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); + Map readDoorLockNumberOfTotalUsersSupportedCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readNumberOfTotalUsersSupportedAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfTotalUsersSupportedCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.put( + "readNumberOfYearDaySchedulesSupportedPerUserAttribute", + readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); + Map readDoorLockMaxPINCodeLengthCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readMaxPINCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMaxPINCodeLengthCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.put( + "readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); + Map readDoorLockLanguageCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockLanguageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readLanguageAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readDoorLockLanguageCommandParams - ); - readDoorLockInteractionInfo.put("readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); - Map readDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readAutoRelockTimeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readDoorLockLanguageCommandParams); + readDoorLockInteractionInfo.put( + "readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); + Map readDoorLockAutoRelockTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readAutoRelockTimeAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockAutoRelockTimeCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readSupportedOperatingModesAttribute", readDoorLockSupportedOperatingModesAttributeInteractionInfo); - Map readDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readEnableOneTouchLockingAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readDoorLockAutoRelockTimeCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.put( + "readSupportedOperatingModesAttribute", + readDoorLockSupportedOperatingModesAttributeInteractionInfo); + Map readDoorLockEnableOneTouchLockingCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readEnableOneTouchLockingAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnableOneTouchLockingCommandParams - ); - readDoorLockInteractionInfo.put("readEnableOneTouchLockingAttribute", readDoorLockEnableOneTouchLockingAttributeInteractionInfo); - Map readDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readEnablePrivacyModeButtonAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readDoorLockEnableOneTouchLockingCommandParams); + readDoorLockInteractionInfo.put( + "readEnableOneTouchLockingAttribute", + readDoorLockEnableOneTouchLockingAttributeInteractionInfo); + Map readDoorLockEnablePrivacyModeButtonCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readEnablePrivacyModeButtonAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnablePrivacyModeButtonCommandParams - ); - readDoorLockInteractionInfo.put("readEnablePrivacyModeButtonAttribute", readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); - Map readDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readWrongCodeEntryLimitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockWrongCodeEntryLimitCommandParams - ); - readDoorLockInteractionInfo.put("readWrongCodeEntryLimitAttribute", readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); - Map readDoorLockAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readAttributeListAttribute( - ( ChipClusters.DoorLockCluster.AttributeListAttributeCallback - ) callback - ); - }, + readDoorLockEnablePrivacyModeButtonCommandParams); + readDoorLockInteractionInfo.put( + "readEnablePrivacyModeButtonAttribute", + readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); + Map readDoorLockWrongCodeEntryLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readWrongCodeEntryLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockWrongCodeEntryLimitCommandParams); + readDoorLockInteractionInfo.put( + "readWrongCodeEntryLimitAttribute", + readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); + Map readDoorLockAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DoorLockCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDoorLockClusterAttributeListAttributeCallback(), - readDoorLockAttributeListCommandParams - ); - readDoorLockInteractionInfo.put("readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); - Map readDoorLockClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockClusterRevisionCommandParams - ); - readDoorLockInteractionInfo.put("readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("doorLock", readDoorLockInteractionInfo); - Map readElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readElectricalMeasurementMeasurementTypeCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasurementTypeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readDoorLockAttributeListCommandParams); + readDoorLockInteractionInfo.put( + "readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); + Map readDoorLockClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockClusterRevisionCommandParams); + readDoorLockInteractionInfo.put( + "readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("doorLock", readDoorLockInteractionInfo); + Map readElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readElectricalMeasurementMeasurementTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasurementTypeAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementMeasurementTypeCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readMeasurementTypeAttribute", readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); - Map readElectricalMeasurementTotalActivePowerCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readTotalActivePowerAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readElectricalMeasurementMeasurementTypeCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readMeasurementTypeAttribute", + readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); + Map readElectricalMeasurementTotalActivePowerCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readTotalActivePowerAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementTotalActivePowerCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readTotalActivePowerAttribute", readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageCommandParams - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.put("readActivePowerMaxAttribute", readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); - Map readElectricalMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), - readElectricalMeasurementAttributeListCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readAttributeListAttribute", readElectricalMeasurementAttributeListAttributeInteractionInfo); - Map readElectricalMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementClusterRevisionCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readClusterRevisionAttribute", readElectricalMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("electricalMeasurement", readElectricalMeasurementInteractionInfo); - Map readEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - Map readEthernetNetworkDiagnosticsPHYRateCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPHYRateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readEthernetNetworkDiagnosticsPHYRateCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFullDuplexAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readElectricalMeasurementTotalActivePowerCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readTotalActivePowerAttribute", + readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageCommandParams); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.put( + "readActivePowerMaxAttribute", + readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); + Map readElectricalMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), + readElectricalMeasurementAttributeListCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readElectricalMeasurementAttributeListAttributeInteractionInfo); + Map readElectricalMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementClusterRevisionCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readElectricalMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("electricalMeasurement", readElectricalMeasurementInteractionInfo); + Map readEthernetNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + Map readEthernetNetworkDiagnosticsPHYRateCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readPHYRateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthernetNetworkDiagnosticsPHYRateCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readFullDuplexAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readEthernetNetworkDiagnosticsFullDuplexCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readFullDuplexAttribute", readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPacketRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsFullDuplexCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readPacketRxCountAttribute", readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPacketTxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsPacketRxCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readPacketTxCountAttribute", readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTxErrCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readTxErrCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsPacketTxCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readTxErrCountAttribute", readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCollisionCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCollisionCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsTxErrCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readCollisionCountAttribute", readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsCollisionCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCarrierDetectAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsOverrunCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readOverrunCountAttribute", + readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readCarrierDetectAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readEthernetNetworkDiagnosticsCarrierDetectCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readCarrierDetectAttribute", readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTimeSinceResetCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readTimeSinceResetAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsCarrierDetectCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readTimeSinceResetAttribute", readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.EthernetNetworkDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readEthernetNetworkDiagnosticsAttributeListCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readAttributeListAttribute", readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsTimeSinceResetCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readTimeSinceResetAttribute", + readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readEthernetNetworkDiagnosticsAttributeListCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo); - Map readFixedLabelInteractionInfo = new LinkedHashMap<>(); - Map readFixedLabelLabelListCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelLabelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readLabelListAttribute( - ( ChipClusters.FixedLabelCluster.LabelListAttributeCallback - ) callback - ); - }, + readEthernetNetworkDiagnosticsFeatureMapCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo); + Map readFixedLabelInteractionInfo = 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 - ); - readFixedLabelInteractionInfo.put("readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); - Map readFixedLabelAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readAttributeListAttribute( - ( ChipClusters.FixedLabelCluster.AttributeListAttributeCallback - ) callback - ); - }, + readFixedLabelLabelListCommandParams); + readFixedLabelInteractionInfo.put( + "readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); + Map readFixedLabelAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.FixedLabelCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedFixedLabelClusterAttributeListAttributeCallback(), - readFixedLabelAttributeListCommandParams - ); - readFixedLabelInteractionInfo.put("readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); - Map readFixedLabelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFixedLabelClusterRevisionCommandParams - ); - readFixedLabelInteractionInfo.put("readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("fixedLabel", readFixedLabelInteractionInfo); - Map readFlowMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readFlowMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMeasuredValueCommandParams - ); - readFlowMeasurementInteractionInfo.put("readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMinMeasuredValueCommandParams - ); - readFlowMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMaxMeasuredValueCommandParams - ); - readFlowMeasurementInteractionInfo.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 - ); - readFlowMeasurementInteractionInfo.put("readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); - Map readFlowMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), - readFlowMeasurementAttributeListCommandParams - ); - readFlowMeasurementInteractionInfo.put("readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); - Map readFlowMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementClusterRevisionCommandParams - ); - readFlowMeasurementInteractionInfo.put("readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("flowMeasurement", readFlowMeasurementInteractionInfo); - Map readGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readBreadcrumbAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readFixedLabelAttributeListCommandParams); + readFixedLabelInteractionInfo.put( + "readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); + Map readFixedLabelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFixedLabelClusterRevisionCommandParams); + readFixedLabelInteractionInfo.put( + "readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("fixedLabel", readFixedLabelInteractionInfo); + Map readFlowMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readFlowMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMeasuredValueCommandParams); + readFlowMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMinMeasuredValueCommandParams); + readFlowMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMaxMeasuredValueCommandParams); + readFlowMeasurementInteractionInfo.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); + readFlowMeasurementInteractionInfo.put( + "readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); + Map readFlowMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), + readFlowMeasurementAttributeListCommandParams); + readFlowMeasurementInteractionInfo.put( + "readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); + Map readFlowMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementClusterRevisionCommandParams); + readFlowMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("flowMeasurement", readFlowMeasurementInteractionInfo); + Map readGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readGeneralCommissioningBreadcrumbCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readBreadcrumbAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralCommissioningBreadcrumbCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); - Map readGeneralCommissioningBasicCommissioningInfoListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readBasicCommissioningInfoListAttribute( - ( ChipClusters.GeneralCommissioningCluster.BasicCommissioningInfoListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback(), - readGeneralCommissioningBasicCommissioningInfoListCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readBasicCommissioningInfoListAttribute", readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo); - Map readGeneralCommissioningRegulatoryConfigCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readRegulatoryConfigAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningRegulatoryConfigCommandParams - ); - readGeneralCommissioningInteractionInfo.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 - ); - readGeneralCommissioningInteractionInfo.put("readLocationCapabilityAttribute", readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); - Map readGeneralCommissioningAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), - readGeneralCommissioningAttributeListCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readAttributeListAttribute", readGeneralCommissioningAttributeListAttributeInteractionInfo); - Map readGeneralCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningClusterRevisionCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readClusterRevisionAttribute", readGeneralCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("generalCommissioning", readGeneralCommissioningInteractionInfo); - Map readGeneralDiagnosticsInteractionInfo = 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 - ); - readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readRebootCountAttribute", readGeneralDiagnosticsRebootCountAttributeInteractionInfo); - Map readGeneralDiagnosticsUpTimeCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsUpTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readUpTimeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readGeneralCommissioningBreadcrumbCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); + Map + readGeneralCommissioningBasicCommissioningInfoListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readBasicCommissioningInfoListAttribute( + (ChipClusters.GeneralCommissioningCluster + .BasicCommissioningInfoListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback(), + readGeneralCommissioningBasicCommissioningInfoListCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readBasicCommissioningInfoListAttribute", + readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo); + Map readGeneralCommissioningRegulatoryConfigCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readRegulatoryConfigAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningRegulatoryConfigCommandParams); + readGeneralCommissioningInteractionInfo.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); + readGeneralCommissioningInteractionInfo.put( + "readLocationCapabilityAttribute", + readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); + Map readGeneralCommissioningAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), + readGeneralCommissioningAttributeListCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readAttributeListAttribute", + readGeneralCommissioningAttributeListAttributeInteractionInfo); + Map readGeneralCommissioningClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningClusterRevisionCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readClusterRevisionAttribute", + readGeneralCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalCommissioning", readGeneralCommissioningInteractionInfo); + Map readGeneralDiagnosticsInteractionInfo = 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); + readGeneralDiagnosticsInteractionInfo.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); + readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readUpTimeAttribute", readGeneralDiagnosticsUpTimeAttributeInteractionInfo); - Map readGeneralDiagnosticsTotalOperationalHoursCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readTotalOperationalHoursAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readGeneralDiagnosticsUpTimeCommandParams); + readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readTotalOperationalHoursAttribute", readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); - Map readGeneralDiagnosticsBootReasonsCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsBootReasonsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readBootReasonsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsBootReasonsCommandParams - ); - readGeneralDiagnosticsInteractionInfo.put("readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeInteractionInfo); - Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readActiveHardwareFaultsAttribute( - ( ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), - readGeneralDiagnosticsActiveHardwareFaultsCommandParams - ); - readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readActiveNetworkFaultsAttribute", readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); - Map readGeneralDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), - readGeneralDiagnosticsAttributeListCommandParams - ); - readGeneralDiagnosticsInteractionInfo.put("readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); - Map readGeneralDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsClusterRevisionCommandParams - ); - readGeneralDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo); - Map readGroupKeyManagementInteractionInfo = 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 - ); - readGroupKeyManagementInteractionInfo.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 - ); - readGroupKeyManagementInteractionInfo.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 - ); - readGroupKeyManagementInteractionInfo.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 - ); - readGroupKeyManagementInteractionInfo.put("readMaxGroupKeysPerFabricAttribute", readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); - Map readGroupKeyManagementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), - readGroupKeyManagementAttributeListCommandParams - ); - readGroupKeyManagementInteractionInfo.put("readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); - Map readGroupKeyManagementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupKeyManagementClusterRevisionCommandParams - ); - readGroupKeyManagementInteractionInfo.put("readClusterRevisionAttribute", readGroupKeyManagementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("groupKeyManagement", readGroupKeyManagementInteractionInfo); - Map readGroupsInteractionInfo = new LinkedHashMap<>(); - Map readGroupsNameSupportCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsNameSupportAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readNameSupportAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsNameSupportCommandParams - ); - readGroupsInteractionInfo.put("readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); - Map readGroupsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GroupsCluster.AttributeListAttributeCallback - ) callback - ); - }, + readGeneralDiagnosticsTotalOperationalHoursCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readTotalOperationalHoursAttribute", + readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); + Map readGeneralDiagnosticsBootReasonsCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsBootReasonsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readBootReasonsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsBootReasonsCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeInteractionInfo); + Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readActiveHardwareFaultsAttribute( + (ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), + readGeneralDiagnosticsActiveHardwareFaultsCommandParams); + readGeneralDiagnosticsInteractionInfo.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); + readGeneralDiagnosticsInteractionInfo.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); + readGeneralDiagnosticsInteractionInfo.put( + "readActiveNetworkFaultsAttribute", + readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); + Map readGeneralDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), + readGeneralDiagnosticsAttributeListCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); + Map readGeneralDiagnosticsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsClusterRevisionCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo); + Map readGroupKeyManagementInteractionInfo = 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); + readGroupKeyManagementInteractionInfo.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); + readGroupKeyManagementInteractionInfo.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); + readGroupKeyManagementInteractionInfo.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); + readGroupKeyManagementInteractionInfo.put( + "readMaxGroupKeysPerFabricAttribute", + readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); + Map readGroupKeyManagementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), + readGroupKeyManagementAttributeListCommandParams); + readGroupKeyManagementInteractionInfo.put( + "readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); + Map readGroupKeyManagementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupKeyManagementClusterRevisionCommandParams); + readGroupKeyManagementInteractionInfo.put( + "readClusterRevisionAttribute", + readGroupKeyManagementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groupKeyManagement", readGroupKeyManagementInteractionInfo); + Map readGroupsInteractionInfo = new LinkedHashMap<>(); + Map readGroupsNameSupportCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsNameSupportAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readNameSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsNameSupportCommandParams); + readGroupsInteractionInfo.put( + "readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); + Map readGroupsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GroupsCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedGroupsClusterAttributeListAttributeCallback(), - readGroupsAttributeListCommandParams - ); - readGroupsInteractionInfo.put("readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); - Map readGroupsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsClusterRevisionCommandParams - ); - readGroupsInteractionInfo.put("readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("groups", readGroupsInteractionInfo); - Map readIdentifyInteractionInfo = new LinkedHashMap<>(); - Map readIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readIdentifyTimeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyIdentifyTimeCommandParams - ); - readIdentifyInteractionInfo.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 - ); - readIdentifyInteractionInfo.put("readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); - Map readIdentifyAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readAttributeListAttribute( - ( ChipClusters.IdentifyCluster.AttributeListAttributeCallback - ) callback - ); - }, + readGroupsAttributeListCommandParams); + readGroupsInteractionInfo.put( + "readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); + Map readGroupsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsClusterRevisionCommandParams); + readGroupsInteractionInfo.put( + "readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groups", readGroupsInteractionInfo); + Map readIdentifyInteractionInfo = new LinkedHashMap<>(); + Map readIdentifyIdentifyTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readIdentifyTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyIdentifyTimeCommandParams); + readIdentifyInteractionInfo.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); + readIdentifyInteractionInfo.put( + "readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); + Map readIdentifyAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.IdentifyCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedIdentifyClusterAttributeListAttributeCallback(), - readIdentifyAttributeListCommandParams - ); - readIdentifyInteractionInfo.put("readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); - Map readIdentifyClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyClusterRevisionCommandParams - ); - readIdentifyInteractionInfo.put("readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("identify", readIdentifyInteractionInfo); - Map readIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readIlluminanceMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMeasuredValueAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMeasuredValueCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readMeasuredValueAttribute", readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMinMeasuredValueCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMaxMeasuredValueCommandParams - ); - readIlluminanceMeasurementInteractionInfo.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 - ); - readIlluminanceMeasurementInteractionInfo.put("readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); - Map readIlluminanceMeasurementLightSensorTypeCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readLightSensorTypeAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementLightSensorTypeCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readLightSensorTypeAttribute", readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); - Map readIlluminanceMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), - readIlluminanceMeasurementAttributeListCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readAttributeListAttribute", readIlluminanceMeasurementAttributeListAttributeInteractionInfo); - Map readIlluminanceMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementClusterRevisionCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readClusterRevisionAttribute", readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo); - Map readKeypadInputInteractionInfo = new LinkedHashMap<>(); - Map readKeypadInputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readAttributeListAttribute( - ( ChipClusters.KeypadInputCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), - readKeypadInputAttributeListCommandParams - ); - readKeypadInputInteractionInfo.put("readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); - Map readKeypadInputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readKeypadInputClusterRevisionCommandParams - ); - readKeypadInputInteractionInfo.put("readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("keypadInput", readKeypadInputInteractionInfo); - Map readLevelControlInteractionInfo = new LinkedHashMap<>(); - Map readLevelControlCurrentLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readCurrentLevelAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlCurrentLevelCommandParams - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.put("readOnOffTransitionTimeAttribute", readLevelControlOnOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlOnLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOnLevelAttribute( - ( ChipClusters.LevelControlCluster.OnLevelAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnLevelCommandParams - ); - readLevelControlInteractionInfo.put("readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); - Map readLevelControlOnTransitionTimeCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOnTransitionTimeAttribute( - ( ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnTransitionTimeCommandParams - ); - readLevelControlInteractionInfo.put("readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); - Map readLevelControlOffTransitionTimeCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOffTransitionTimeAttribute( - ( ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOffTransitionTimeCommandParams - ); - readLevelControlInteractionInfo.put("readOffTransitionTimeAttribute", readLevelControlOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlDefaultMoveRateCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readDefaultMoveRateAttribute( - ( ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlDefaultMoveRateCommandParams - ); - readLevelControlInteractionInfo.put("readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); - Map readLevelControlStartUpCurrentLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readStartUpCurrentLevelAttribute( - ( ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlStartUpCurrentLevelCommandParams - ); - readLevelControlInteractionInfo.put("readStartUpCurrentLevelAttribute", readLevelControlStartUpCurrentLevelAttributeInteractionInfo); - Map readLevelControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.LevelControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), - readLevelControlAttributeListCommandParams - ); - readLevelControlInteractionInfo.put("readAttributeListAttribute", readLevelControlAttributeListAttributeInteractionInfo); - Map readLevelControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readIdentifyAttributeListCommandParams); + readIdentifyInteractionInfo.put( + "readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); + Map readIdentifyClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyClusterRevisionCommandParams); + readIdentifyInteractionInfo.put( + "readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("identify", readIdentifyInteractionInfo); + Map readIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readIlluminanceMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMeasuredValueCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", + readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMinMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMinMeasuredValueCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMaxMeasuredValueCommandParams); + readIlluminanceMeasurementInteractionInfo.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); + readIlluminanceMeasurementInteractionInfo.put( + "readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); + Map readIlluminanceMeasurementLightSensorTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readLightSensorTypeAttribute( + (ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementLightSensorTypeCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readLightSensorTypeAttribute", + readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); + Map readIlluminanceMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), + readIlluminanceMeasurementAttributeListCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readIlluminanceMeasurementAttributeListAttributeInteractionInfo); + Map readIlluminanceMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementClusterRevisionCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo); + Map readKeypadInputInteractionInfo = new LinkedHashMap<>(); + Map readKeypadInputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.KeypadInputCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), + readKeypadInputAttributeListCommandParams); + readKeypadInputInteractionInfo.put( + "readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); + Map readKeypadInputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readKeypadInputClusterRevisionCommandParams); + readKeypadInputInteractionInfo.put( + "readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("keypadInput", readKeypadInputInteractionInfo); + Map readLevelControlInteractionInfo = new LinkedHashMap<>(); + Map readLevelControlCurrentLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readCurrentLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlCurrentLevelCommandParams); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.put( + "readOnOffTransitionTimeAttribute", + readLevelControlOnOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlOnLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOnLevelAttribute( + (ChipClusters.LevelControlCluster.OnLevelAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnLevelCommandParams); + readLevelControlInteractionInfo.put( + "readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); + Map readLevelControlOnTransitionTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOnTransitionTimeAttribute( + (ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnTransitionTimeCommandParams); + readLevelControlInteractionInfo.put( + "readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); + Map readLevelControlOffTransitionTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOffTransitionTimeAttribute( + (ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOffTransitionTimeCommandParams); + readLevelControlInteractionInfo.put( + "readOffTransitionTimeAttribute", + readLevelControlOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlDefaultMoveRateCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readDefaultMoveRateAttribute( + (ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlDefaultMoveRateCommandParams); + readLevelControlInteractionInfo.put( + "readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); + Map readLevelControlStartUpCurrentLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readStartUpCurrentLevelAttribute( + (ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlStartUpCurrentLevelCommandParams); + readLevelControlInteractionInfo.put( + "readStartUpCurrentLevelAttribute", + readLevelControlStartUpCurrentLevelAttributeInteractionInfo); + Map readLevelControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.LevelControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), + readLevelControlAttributeListCommandParams); + readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.put("readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("levelControl", readLevelControlInteractionInfo); - Map readLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); - Map readLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readActiveLocaleAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readLevelControlFeatureMapCommandParams); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.put( + "readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("levelControl", readLevelControlInteractionInfo); + Map readLocalizationConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map readLocalizationConfigurationActiveLocaleCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readActiveLocaleAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readLocalizationConfigurationActiveLocaleCommandParams - ); - readLocalizationConfigurationInteractionInfo.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 - ); - readLocalizationConfigurationInteractionInfo.put("readSupportedLocalesAttribute", readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); - Map readLocalizationConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLocalizationConfigurationClusterRevisionCommandParams - ); - readLocalizationConfigurationInteractionInfo.put("readClusterRevisionAttribute", readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("localizationConfiguration", readLocalizationConfigurationInteractionInfo); - Map readLowPowerInteractionInfo = new LinkedHashMap<>(); - Map readLowPowerAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readAttributeListAttribute( - ( ChipClusters.LowPowerCluster.AttributeListAttributeCallback - ) callback - ); - }, + readLocalizationConfigurationActiveLocaleCommandParams); + readLocalizationConfigurationInteractionInfo.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); + readLocalizationConfigurationInteractionInfo.put( + "readSupportedLocalesAttribute", + readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); + Map readLocalizationConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLocalizationConfigurationClusterRevisionCommandParams); + readLocalizationConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("localizationConfiguration", readLocalizationConfigurationInteractionInfo); + Map readLowPowerInteractionInfo = new LinkedHashMap<>(); + Map readLowPowerAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.LowPowerCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLowPowerClusterAttributeListAttributeCallback(), - readLowPowerAttributeListCommandParams - ); - readLowPowerInteractionInfo.put("readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); - Map readLowPowerClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLowPowerClusterRevisionCommandParams - ); - readLowPowerInteractionInfo.put("readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("lowPower", readLowPowerInteractionInfo); - Map readMediaInputInteractionInfo = new LinkedHashMap<>(); - Map readMediaInputMediaInputListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputMediaInputListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readMediaInputListAttribute( - ( ChipClusters.MediaInputCluster.MediaInputListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaInputClusterMediaInputListAttributeCallback(), - readMediaInputMediaInputListCommandParams - ); - readMediaInputInteractionInfo.put("readMediaInputListAttribute", readMediaInputMediaInputListAttributeInteractionInfo); - Map readMediaInputCurrentMediaInputCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputCurrentMediaInputAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readCurrentMediaInputAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputCurrentMediaInputCommandParams - ); - readMediaInputInteractionInfo.put("readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeInteractionInfo); - Map readMediaInputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readAttributeListAttribute( - ( ChipClusters.MediaInputCluster.AttributeListAttributeCallback - ) callback - ); - }, + readLowPowerAttributeListCommandParams); + readLowPowerInteractionInfo.put( + "readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); + Map readLowPowerClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLowPowerClusterRevisionCommandParams); + readLowPowerInteractionInfo.put( + "readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("lowPower", readLowPowerInteractionInfo); + Map readMediaInputInteractionInfo = new LinkedHashMap<>(); + Map readMediaInputMediaInputListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputMediaInputListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readMediaInputListAttribute( + (ChipClusters.MediaInputCluster.MediaInputListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedMediaInputClusterMediaInputListAttributeCallback(), + readMediaInputMediaInputListCommandParams); + readMediaInputInteractionInfo.put( + "readMediaInputListAttribute", readMediaInputMediaInputListAttributeInteractionInfo); + Map readMediaInputCurrentMediaInputCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputCurrentMediaInputAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readCurrentMediaInputAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputCurrentMediaInputCommandParams); + readMediaInputInteractionInfo.put( + "readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeInteractionInfo); + Map readMediaInputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.MediaInputCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedMediaInputClusterAttributeListAttributeCallback(), - readMediaInputAttributeListCommandParams - ); - readMediaInputInteractionInfo.put("readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); - Map readMediaInputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputClusterRevisionCommandParams - ); - readMediaInputInteractionInfo.put("readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("mediaInput", readMediaInputInteractionInfo); - Map readMediaPlaybackInteractionInfo = new LinkedHashMap<>(); - Map readMediaPlaybackPlaybackStateCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readPlaybackStateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackPlaybackStateCommandParams - ); - readMediaPlaybackInteractionInfo.put("readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeInteractionInfo); - Map readMediaPlaybackStartTimeCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readStartTimeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaInputAttributeListCommandParams); + readMediaInputInteractionInfo.put( + "readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); + Map readMediaInputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputClusterRevisionCommandParams); + readMediaInputInteractionInfo.put( + "readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaInput", readMediaInputInteractionInfo); + Map readMediaPlaybackInteractionInfo = new LinkedHashMap<>(); + Map readMediaPlaybackPlaybackStateCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackPlaybackStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readPlaybackStateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackPlaybackStateCommandParams); + readMediaPlaybackInteractionInfo.put( + "readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeInteractionInfo); + Map readMediaPlaybackStartTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readStartTimeAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackStartTimeCommandParams - ); - readMediaPlaybackInteractionInfo.put("readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); - Map readMediaPlaybackDurationCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readDurationAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaPlaybackStartTimeCommandParams); + readMediaPlaybackInteractionInfo.put( + "readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); + Map readMediaPlaybackDurationCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readDurationAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackDurationCommandParams - ); - readMediaPlaybackInteractionInfo.put("readDurationAttribute", readMediaPlaybackDurationAttributeInteractionInfo); - Map readMediaPlaybackPlaybackSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readPlaybackSpeedAttribute( - ( - ChipClusters.FloatAttributeCallback -) callback - ); - }, + readMediaPlaybackDurationCommandParams); + readMediaPlaybackInteractionInfo.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 - ); - readMediaPlaybackInteractionInfo.put("readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeEndCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeEndAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaPlaybackPlaybackSpeedCommandParams); + readMediaPlaybackInteractionInfo.put( + "readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeEndCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readSeekRangeEndAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackSeekRangeEndCommandParams - ); - readMediaPlaybackInteractionInfo.put("readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeStartCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeStartAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaPlaybackSeekRangeEndCommandParams); + readMediaPlaybackInteractionInfo.put( + "readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeStartCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readSeekRangeStartAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackSeekRangeStartCommandParams - ); - readMediaPlaybackInteractionInfo.put("readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); - Map readMediaPlaybackAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readAttributeListAttribute( - ( ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), - readMediaPlaybackAttributeListCommandParams - ); - readMediaPlaybackInteractionInfo.put("readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); - Map readMediaPlaybackClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackClusterRevisionCommandParams - ); - readMediaPlaybackInteractionInfo.put("readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("mediaPlayback", readMediaPlaybackInteractionInfo); - Map readModeSelectInteractionInfo = new LinkedHashMap<>(); - Map readModeSelectCurrentModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readCurrentModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectCurrentModeCommandParams - ); - readModeSelectInteractionInfo.put("readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); - Map readModeSelectSupportedModesCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readSupportedModesAttribute( - ( ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), - readModeSelectSupportedModesCommandParams - ); - readModeSelectInteractionInfo.put("readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); - Map readModeSelectOnModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectOnModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readOnModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectOnModeCommandParams - ); - readModeSelectInteractionInfo.put("readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); - Map readModeSelectStartUpModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readStartUpModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectStartUpModeCommandParams - ); - readModeSelectInteractionInfo.put("readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); - Map readModeSelectDescriptionCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readDescriptionAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readMediaPlaybackSeekRangeStartCommandParams); + readMediaPlaybackInteractionInfo.put( + "readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); + Map readMediaPlaybackAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), + readMediaPlaybackAttributeListCommandParams); + readMediaPlaybackInteractionInfo.put( + "readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); + Map readMediaPlaybackClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackClusterRevisionCommandParams); + readMediaPlaybackInteractionInfo.put( + "readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaPlayback", readMediaPlaybackInteractionInfo); + Map readModeSelectInteractionInfo = new LinkedHashMap<>(); + Map readModeSelectCurrentModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readCurrentModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectCurrentModeCommandParams); + readModeSelectInteractionInfo.put( + "readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); + Map readModeSelectSupportedModesCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readSupportedModesAttribute( + (ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), + readModeSelectSupportedModesCommandParams); + readModeSelectInteractionInfo.put( + "readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); + Map readModeSelectOnModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectOnModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readOnModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectOnModeCommandParams); + readModeSelectInteractionInfo.put( + "readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); + Map readModeSelectStartUpModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readStartUpModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectStartUpModeCommandParams); + readModeSelectInteractionInfo.put( + "readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); + Map readModeSelectDescriptionCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readModeSelectDescriptionCommandParams - ); - readModeSelectInteractionInfo.put("readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); - Map readModeSelectAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ModeSelectCluster.AttributeListAttributeCallback - ) callback - ); - }, + readModeSelectDescriptionCommandParams); + readModeSelectInteractionInfo.put( + "readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); + Map readModeSelectAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ModeSelectCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedModeSelectClusterAttributeListAttributeCallback(), - readModeSelectAttributeListCommandParams - ); - readModeSelectInteractionInfo.put("readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); - Map readModeSelectClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectClusterRevisionCommandParams - ); - readModeSelectInteractionInfo.put("readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("modeSelect", readModeSelectInteractionInfo); - Map readNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readNetworkCommissioningMaxNetworksCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readMaxNetworksAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningMaxNetworksCommandParams - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.put("readConnectMaxTimeSecondsAttribute", readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo); - Map readNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readInterfaceEnabledAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readModeSelectAttributeListCommandParams); + readModeSelectInteractionInfo.put( + "readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); + Map readModeSelectClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectClusterRevisionCommandParams); + readModeSelectInteractionInfo.put( + "readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("modeSelect", readModeSelectInteractionInfo); + Map readNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readNetworkCommissioningMaxNetworksCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readMaxNetworksAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningMaxNetworksCommandParams); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.put("readInterfaceEnabledAttribute", readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkingStatusCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkingStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningLastNetworkingStatusCommandParams - ); - readNetworkCommissioningInteractionInfo.put("readLastNetworkingStatusAttribute", readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkIDCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkIDAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readNetworkCommissioningInterfaceEnabledCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readInterfaceEnabledAttribute", + readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkingStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastNetworkingStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningLastNetworkingStatusCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readLastNetworkingStatusAttribute", + readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkIDCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastNetworkIDAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readNetworkCommissioningLastNetworkIDCommandParams - ); - readNetworkCommissioningInteractionInfo.put("readLastNetworkIDAttribute", readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); - Map readNetworkCommissioningLastConnectErrorValueCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastConnectErrorValueAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readNetworkCommissioningLastNetworkIDCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readLastNetworkIDAttribute", + readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); + Map readNetworkCommissioningLastConnectErrorValueCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastConnectErrorValueAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningLastConnectErrorValueCommandParams - ); - readNetworkCommissioningInteractionInfo.put("readLastConnectErrorValueAttribute", readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); - Map readNetworkCommissioningFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readNetworkCommissioningLastConnectErrorValueCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readLastConnectErrorValueAttribute", + readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); + Map readNetworkCommissioningFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningFeatureMapCommandParams - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.put("readClusterRevisionAttribute", readNetworkCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("networkCommissioning", readNetworkCommissioningInteractionInfo); - Map readOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); - Map readOtaSoftwareUpdateProviderAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateProviderAttributeListCommandParams - ); - readOtaSoftwareUpdateProviderInteractionInfo.put("readAttributeListAttribute", readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateProviderClusterRevisionCommandParams - ); - readOtaSoftwareUpdateProviderInteractionInfo.put("readClusterRevisionAttribute", readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo); - Map readOtaSoftwareUpdateRequestorInteractionInfo = 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 - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readDefaultOtaProvidersAttribute", readOtaSoftwareUpdateRequestorDefaultOtaProvidersAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdatePossibleAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readNetworkCommissioningFeatureMapCommandParams); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.put( + "readClusterRevisionAttribute", + readNetworkCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("networkCommissioning", readNetworkCommissioningInteractionInfo); + Map readOtaSoftwareUpdateProviderInteractionInfo = + new LinkedHashMap<>(); + Map readOtaSoftwareUpdateProviderAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateProviderAttributeListCommandParams); + readOtaSoftwareUpdateProviderInteractionInfo.put( + "readAttributeListAttribute", + readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateProviderClusterRevisionCommandParams); + readOtaSoftwareUpdateProviderInteractionInfo.put( + "readClusterRevisionAttribute", + readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo); + Map readOtaSoftwareUpdateRequestorInteractionInfo = + 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); + readOtaSoftwareUpdateRequestorInteractionInfo.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 - ); - readOtaSoftwareUpdateRequestorInteractionInfo.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 - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readUpdateStateAttribute", readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdateStateProgressAttribute( - ( ChipClusters.OtaSoftwareUpdateRequestorCluster.UpdateStateProgressAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readUpdateStateProgressAttribute", readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OtaSoftwareUpdateRequestorCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateRequestorAttributeListCommandParams - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readAttributeListAttribute", readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorClusterRevisionCommandParams - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readClusterRevisionAttribute", readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo); - Map readOccupancySensingInteractionInfo = new LinkedHashMap<>(); - Map readOccupancySensingOccupancyCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readOccupancyAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingOccupancyCommandParams - ); - readOccupancySensingInteractionInfo.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 - ); - readOccupancySensingInteractionInfo.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 - ); - readOccupancySensingInteractionInfo.put("readOccupancySensorTypeBitmapAttribute", readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); - Map readOccupancySensingAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterAttributeListAttributeCallback(), - readOccupancySensingAttributeListCommandParams - ); - readOccupancySensingInteractionInfo.put("readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); - Map readOccupancySensingClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingClusterRevisionCommandParams - ); - readOccupancySensingInteractionInfo.put("readClusterRevisionAttribute", readOccupancySensingClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("occupancySensing", readOccupancySensingInteractionInfo); - Map readOnOffInteractionInfo = new LinkedHashMap<>(); - Map readOnOffOnOffCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffOnOffAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readOnOffAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.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); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readUpdateStateAttribute", + readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); + Map + readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readUpdateStateProgressAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster + .UpdateStateProgressAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readUpdateStateProgressAttribute", + readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateRequestorAttributeListCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readAttributeListAttribute", + readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorClusterRevisionCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readClusterRevisionAttribute", + readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo); + Map readOccupancySensingInteractionInfo = new LinkedHashMap<>(); + Map readOccupancySensingOccupancyCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readOccupancyAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingOccupancyCommandParams); + readOccupancySensingInteractionInfo.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); + readOccupancySensingInteractionInfo.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); + readOccupancySensingInteractionInfo.put( + "readOccupancySensorTypeBitmapAttribute", + readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); + Map readOccupancySensingAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOccupancySensingClusterAttributeListAttributeCallback(), + readOccupancySensingAttributeListCommandParams); + readOccupancySensingInteractionInfo.put( + "readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); + Map readOccupancySensingClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingClusterRevisionCommandParams); + readOccupancySensingInteractionInfo.put( + "readClusterRevisionAttribute", + readOccupancySensingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("occupancySensing", readOccupancySensingInteractionInfo); + Map readOnOffInteractionInfo = new LinkedHashMap<>(); + Map readOnOffOnOffCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffOnOffAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readOnOffAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOnOffOnOffCommandParams - ); - readOnOffInteractionInfo.put("readOnOffAttribute", readOnOffOnOffAttributeInteractionInfo); - Map readOnOffGlobalSceneControlCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffGlobalSceneControlAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readGlobalSceneControlAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readOnOffOnOffCommandParams); + readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.put("readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); - Map readOnOffStartUpOnOffCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readStartUpOnOffAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffStartUpOnOffCommandParams - ); - readOnOffInteractionInfo.put("readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); - Map readOnOffAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OnOffCluster.AttributeListAttributeCallback - ) callback - ); - }, + readOnOffGlobalSceneControlCommandParams); + readOnOffInteractionInfo.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); + readOnOffInteractionInfo.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); + readOnOffInteractionInfo.put( + "readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); + Map readOnOffStartUpOnOffCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readStartUpOnOffAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffStartUpOnOffCommandParams); + readOnOffInteractionInfo.put( + "readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); + Map readOnOffAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OnOffCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOnOffClusterAttributeListAttributeCallback(), - readOnOffAttributeListCommandParams - ); - readOnOffInteractionInfo.put("readAttributeListAttribute", readOnOffAttributeListAttributeInteractionInfo); - Map readOnOffFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readOnOffAttributeListCommandParams); + readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.put("readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("onOff", readOnOffInteractionInfo); - Map readOnOffSwitchConfigurationInteractionInfo = new LinkedHashMap<>(); - Map readOnOffSwitchConfigurationSwitchTypeCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readSwitchTypeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationSwitchTypeCommandParams - ); - readOnOffSwitchConfigurationInteractionInfo.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 - ); - readOnOffSwitchConfigurationInteractionInfo.put("readSwitchActionsAttribute", readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); - Map readOnOffSwitchConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), - readOnOffSwitchConfigurationAttributeListCommandParams - ); - readOnOffSwitchConfigurationInteractionInfo.put("readAttributeListAttribute", readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationClusterRevisionCommandParams - ); - readOnOffSwitchConfigurationInteractionInfo.put("readClusterRevisionAttribute", readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo); - Map readOperationalCredentialsInteractionInfo = 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 - ); - readOperationalCredentialsInteractionInfo.put("readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); - Map readOperationalCredentialsFabricsListCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsFabricsListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readFabricsListAttribute( - ( ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterFabricsListAttributeCallback(), - readOperationalCredentialsFabricsListCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeInteractionInfo); - Map readOperationalCredentialsSupportedFabricsCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readSupportedFabricsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsSupportedFabricsCommandParams - ); - readOperationalCredentialsInteractionInfo.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 - ); - readOperationalCredentialsInteractionInfo.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 - ); - readOperationalCredentialsInteractionInfo.put("readTrustedRootCertificatesAttribute", readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); - Map readOperationalCredentialsCurrentFabricIndexCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readCurrentFabricIndexAttribute( - ( ChipClusters.OperationalCredentialsCluster.CurrentFabricIndexAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsCurrentFabricIndexCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readCurrentFabricIndexAttribute", readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); - Map readOperationalCredentialsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), - readOperationalCredentialsAttributeListCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readAttributeListAttribute", readOperationalCredentialsAttributeListAttributeInteractionInfo); - Map readOperationalCredentialsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsClusterRevisionCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readClusterRevisionAttribute", readOperationalCredentialsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("operationalCredentials", readOperationalCredentialsInteractionInfo); - Map readPowerSourceInteractionInfo = new LinkedHashMap<>(); - Map readPowerSourceStatusCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceStatusCommandParams - ); - readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.put("readOrderAttribute", readPowerSourceOrderAttributeInteractionInfo); - Map readPowerSourceDescriptionCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceDescriptionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readDescriptionAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readOnOffFeatureMapCommandParams); + readOnOffInteractionInfo.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); + readOnOffInteractionInfo.put( + "readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOff", readOnOffInteractionInfo); + Map readOnOffSwitchConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map readOnOffSwitchConfigurationSwitchTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readSwitchTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationSwitchTypeCommandParams); + readOnOffSwitchConfigurationInteractionInfo.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); + readOnOffSwitchConfigurationInteractionInfo.put( + "readSwitchActionsAttribute", + readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); + Map readOnOffSwitchConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), + readOnOffSwitchConfigurationAttributeListCommandParams); + readOnOffSwitchConfigurationInteractionInfo.put( + "readAttributeListAttribute", + readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationClusterRevisionCommandParams); + readOnOffSwitchConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo); + Map readOperationalCredentialsInteractionInfo = 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); + readOperationalCredentialsInteractionInfo.put( + "readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); + Map readOperationalCredentialsFabricsListCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsFabricsListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readFabricsListAttribute( + (ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterFabricsListAttributeCallback(), + readOperationalCredentialsFabricsListCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeInteractionInfo); + Map readOperationalCredentialsSupportedFabricsCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readSupportedFabricsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsSupportedFabricsCommandParams); + readOperationalCredentialsInteractionInfo.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); + readOperationalCredentialsInteractionInfo.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); + readOperationalCredentialsInteractionInfo.put( + "readTrustedRootCertificatesAttribute", + readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); + Map readOperationalCredentialsCurrentFabricIndexCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readCurrentFabricIndexAttribute( + (ChipClusters.OperationalCredentialsCluster + .CurrentFabricIndexAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsCurrentFabricIndexCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readCurrentFabricIndexAttribute", + readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); + Map readOperationalCredentialsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), + readOperationalCredentialsAttributeListCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readAttributeListAttribute", + readOperationalCredentialsAttributeListAttributeInteractionInfo); + Map readOperationalCredentialsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsClusterRevisionCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readClusterRevisionAttribute", + readOperationalCredentialsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("operationalCredentials", readOperationalCredentialsInteractionInfo); + Map readPowerSourceInteractionInfo = new LinkedHashMap<>(); + Map readPowerSourceStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceStatusCommandParams); + readPowerSourceInteractionInfo.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); + readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.put("readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); - Map readPowerSourceBatteryVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryVoltageAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPowerSourceDescriptionCommandParams); + readPowerSourceInteractionInfo.put( + "readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); + Map readPowerSourceBatteryVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryVoltageAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatteryVoltageCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeInteractionInfo); - Map readPowerSourceBatteryPercentRemainingCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryPercentRemainingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryPercentRemainingAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryPercentRemainingCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryPercentRemainingAttribute", readPowerSourceBatteryPercentRemainingAttributeInteractionInfo); - Map readPowerSourceBatteryTimeRemainingCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryTimeRemainingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryTimeRemainingAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPowerSourceBatteryVoltageCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeInteractionInfo); + Map readPowerSourceBatteryPercentRemainingCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryPercentRemainingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryPercentRemainingAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryPercentRemainingCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryPercentRemainingAttribute", + readPowerSourceBatteryPercentRemainingAttributeInteractionInfo); + Map readPowerSourceBatteryTimeRemainingCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryTimeRemainingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryTimeRemainingAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatteryTimeRemainingCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryTimeRemainingAttribute", readPowerSourceBatteryTimeRemainingAttributeInteractionInfo); - Map readPowerSourceBatteryChargeLevelCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryChargeLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryChargeLevelAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryChargeLevelCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryChargeLevelAttribute", readPowerSourceBatteryChargeLevelAttributeInteractionInfo); - Map readPowerSourceActiveBatteryFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceActiveBatteryFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readActiveBatteryFaultsAttribute( - ( ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback(), - readPowerSourceActiveBatteryFaultsCommandParams - ); - readPowerSourceInteractionInfo.put("readActiveBatteryFaultsAttribute", readPowerSourceActiveBatteryFaultsAttributeInteractionInfo); - Map readPowerSourceBatteryChargeStateCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryChargeStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryChargeStateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryChargeStateCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryChargeStateAttribute", readPowerSourceBatteryChargeStateAttributeInteractionInfo); - Map readPowerSourceAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PowerSourceCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), - readPowerSourceAttributeListCommandParams - ); - readPowerSourceInteractionInfo.put("readAttributeListAttribute", readPowerSourceAttributeListAttributeInteractionInfo); - Map readPowerSourceFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPowerSourceBatteryTimeRemainingCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryTimeRemainingAttribute", + readPowerSourceBatteryTimeRemainingAttributeInteractionInfo); + Map readPowerSourceBatteryChargeLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryChargeLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryChargeLevelAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryChargeLevelCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryChargeLevelAttribute", + readPowerSourceBatteryChargeLevelAttributeInteractionInfo); + Map readPowerSourceActiveBatteryFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceActiveBatteryFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readActiveBatteryFaultsAttribute( + (ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback(), + readPowerSourceActiveBatteryFaultsCommandParams); + readPowerSourceInteractionInfo.put( + "readActiveBatteryFaultsAttribute", + readPowerSourceActiveBatteryFaultsAttributeInteractionInfo); + Map readPowerSourceBatteryChargeStateCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryChargeStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryChargeStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryChargeStateCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryChargeStateAttribute", + readPowerSourceBatteryChargeStateAttributeInteractionInfo); + Map readPowerSourceAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PowerSourceCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), + readPowerSourceAttributeListCommandParams); + readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.put("readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("powerSource", readPowerSourceInteractionInfo); - Map readPowerSourceConfigurationInteractionInfo = 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 - ); - readPowerSourceConfigurationInteractionInfo.put("readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); - Map readPowerSourceConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), - readPowerSourceConfigurationAttributeListCommandParams - ); - readPowerSourceConfigurationInteractionInfo.put("readAttributeListAttribute", readPowerSourceConfigurationAttributeListAttributeInteractionInfo); - Map readPowerSourceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceConfigurationClusterRevisionCommandParams - ); - readPowerSourceConfigurationInteractionInfo.put("readClusterRevisionAttribute", readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo); - Map readPressureMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readPressureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMeasuredValueCommandParams - ); - readPressureMeasurementInteractionInfo.put("readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMinMeasuredValueCommandParams - ); - readPressureMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMaxMeasuredValueCommandParams - ); - readPressureMeasurementInteractionInfo.put("readMaxMeasuredValueAttribute", readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), - readPressureMeasurementAttributeListCommandParams - ); - readPressureMeasurementInteractionInfo.put("readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); - Map readPressureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementClusterRevisionCommandParams - ); - readPressureMeasurementInteractionInfo.put("readClusterRevisionAttribute", readPressureMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("pressureMeasurement", readPressureMeasurementInteractionInfo); - Map readPumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); - Map readPumpConfigurationAndControlMaxPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxPressureAttribute", readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxFlowAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxFlowCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstPressureAttribute", readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxConstPressureAttribute", readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinCompPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinCompPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinCompPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinCompPressureAttribute", readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxCompPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxCompPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxCompPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxCompPressureAttribute", readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstSpeedAttribute", readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxConstSpeedAttribute", readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstFlowAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstFlowCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstFlowAttribute", readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstFlowAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstFlowCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxConstFlowAttribute", readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstTempCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstTempAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstTempCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstTempAttribute", readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstTempCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstTempAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstTempCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.put("readEffectiveControlModeAttribute", readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlCapacityCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readCapacityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlCapacityCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); - Map readPumpConfigurationAndControlSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeRunningHoursAttribute( - ( ChipClusters.PumpConfigurationAndControlCluster.LifetimeRunningHoursAttributeCallback - ) callback - ); - }, + readPowerSourceFeatureMapCommandParams); + readPowerSourceInteractionInfo.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); + readPowerSourceInteractionInfo.put( + "readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("powerSource", readPowerSourceInteractionInfo); + Map readPowerSourceConfigurationInteractionInfo = + 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); + readPowerSourceConfigurationInteractionInfo.put( + "readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); + Map readPowerSourceConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), + readPowerSourceConfigurationAttributeListCommandParams); + readPowerSourceConfigurationInteractionInfo.put( + "readAttributeListAttribute", + readPowerSourceConfigurationAttributeListAttributeInteractionInfo); + Map readPowerSourceConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceConfigurationClusterRevisionCommandParams); + readPowerSourceConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo); + Map readPressureMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readPressureMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMeasuredValueCommandParams); + readPressureMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMinMeasuredValueCommandParams); + readPressureMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMaxMeasuredValueCommandParams); + readPressureMeasurementInteractionInfo.put( + "readMaxMeasuredValueAttribute", + readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), + readPressureMeasurementAttributeListCommandParams); + readPressureMeasurementInteractionInfo.put( + "readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); + Map readPressureMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementClusterRevisionCommandParams); + readPressureMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readPressureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("pressureMeasurement", readPressureMeasurementInteractionInfo); + Map readPumpConfigurationAndControlInteractionInfo = + new LinkedHashMap<>(); + Map readPumpConfigurationAndControlMaxPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxPressureAttribute", + readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxFlowCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstPressureAttribute", + readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxConstPressureAttribute", + readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinCompPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinCompPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinCompPressureAttribute", + readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxCompPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxCompPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxCompPressureAttribute", + readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstSpeedAttribute", + readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxConstSpeedAttribute", + readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstFlowCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstFlowAttribute", + readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstFlowCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxConstFlowAttribute", + readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstTempCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstTempCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstTempAttribute", + readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstTempCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstTempCommandParams); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.put( + "readEffectiveControlModeAttribute", + readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlCapacityCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readCapacityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlCapacityCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); + Map readPumpConfigurationAndControlSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); + Map + readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readLifetimeRunningHoursAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .LifetimeRunningHoursAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlLifetimeRunningHoursCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readLifetimeRunningHoursAttribute", readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); - Map readPumpConfigurationAndControlPowerCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readPowerAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPumpConfigurationAndControlLifetimeRunningHoursCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readLifetimeRunningHoursAttribute", + readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); + Map readPumpConfigurationAndControlPowerCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readPowerAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlPowerCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); - Map readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeEnergyConsumedAttribute( - ( ChipClusters.PumpConfigurationAndControlCluster.LifetimeEnergyConsumedAttributeCallback - ) callback - ); - }, + readPumpConfigurationAndControlPowerCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); + Map + readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readLifetimeEnergyConsumedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .LifetimeEnergyConsumedAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.put("readControlModeAttribute", readPumpConfigurationAndControlControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlAlarmMaskCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAlarmMaskAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlAlarmMaskCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo); - Map readPumpConfigurationAndControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PumpConfigurationAndControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), - readPumpConfigurationAndControlAttributeListCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readAttributeListAttribute", readPumpConfigurationAndControlAttributeListAttributeInteractionInfo); - Map readPumpConfigurationAndControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.put( + "readControlModeAttribute", + readPumpConfigurationAndControlControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlAlarmMaskCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readAlarmMaskAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlAlarmMaskCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo); + Map readPumpConfigurationAndControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), + readPumpConfigurationAndControlAttributeListCommandParams); + readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.put("readClusterRevisionAttribute", readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo); - Map readRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readRelativeHumidityMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMeasuredValueCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readMeasuredValueAttribute", readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMinMeasuredValueCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMaxMeasuredValueCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.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 - ); - readRelativeHumidityMeasurementInteractionInfo.put("readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); - Map readRelativeHumidityMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.RelativeHumidityMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), - readRelativeHumidityMeasurementAttributeListCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readAttributeListAttribute", readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementClusterRevisionCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readClusterRevisionAttribute", readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo); - Map readScenesInteractionInfo = new LinkedHashMap<>(); - Map readScenesSceneCountCommandParams = new LinkedHashMap(); - InteractionInfo readScenesSceneCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readSceneCountAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesSceneCountCommandParams - ); - readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.put("readCurrentGroupAttribute", readScenesCurrentGroupAttributeInteractionInfo); - Map readScenesSceneValidCommandParams = new LinkedHashMap(); - InteractionInfo readScenesSceneValidAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readSceneValidAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readPumpConfigurationAndControlFeatureMapCommandParams); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.put( + "readClusterRevisionAttribute", + readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo); + Map readRelativeHumidityMeasurementInteractionInfo = + new LinkedHashMap<>(); + Map readRelativeHumidityMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMeasuredValueCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", + readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMinMeasuredValueCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMaxMeasuredValueCommandParams); + readRelativeHumidityMeasurementInteractionInfo.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); + readRelativeHumidityMeasurementInteractionInfo.put( + "readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); + Map readRelativeHumidityMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), + readRelativeHumidityMeasurementAttributeListCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementClusterRevisionCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo); + Map readScenesInteractionInfo = new LinkedHashMap<>(); + Map readScenesSceneCountCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesSceneCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readSceneCountAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesSceneCountCommandParams); + readScenesInteractionInfo.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); + readScenesInteractionInfo.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); + readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.put("readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); - Map readScenesAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readScenesAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ScenesCluster.AttributeListAttributeCallback - ) callback - ); - }, + readScenesSceneValidCommandParams); + readScenesInteractionInfo.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); + readScenesInteractionInfo.put( + "readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); + Map readScenesAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ScenesCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedScenesClusterAttributeListAttributeCallback(), - readScenesAttributeListCommandParams - ); - readScenesInteractionInfo.put("readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); - Map readScenesClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesClusterRevisionCommandParams - ); - readScenesInteractionInfo.put("readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("scenes", readScenesInteractionInfo); - Map readSoftwareDiagnosticsInteractionInfo = 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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readThreadMetricsAttribute", readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapFreeCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapFreeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readScenesAttributeListCommandParams); + readScenesInteractionInfo.put( + "readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); + Map readScenesClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesClusterRevisionCommandParams); + readScenesInteractionInfo.put( + "readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("scenes", readScenesInteractionInfo); + Map readSoftwareDiagnosticsInteractionInfo = 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); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readCurrentHeapFreeAttribute", readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapUsedCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapUsedAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSoftwareDiagnosticsCurrentHeapFreeCommandParams); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readCurrentHeapUsedAttribute", readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapHighWatermarkAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSoftwareDiagnosticsCurrentHeapUsedCommandParams); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readCurrentHeapHighWatermarkAttribute", readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); - Map readSoftwareDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), - readSoftwareDiagnosticsAttributeListCommandParams - ); - readSoftwareDiagnosticsInteractionInfo.put("readAttributeListAttribute", readSoftwareDiagnosticsAttributeListAttributeInteractionInfo); - Map readSoftwareDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams); + readSoftwareDiagnosticsInteractionInfo.put( + "readCurrentHeapHighWatermarkAttribute", + readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); + Map readSoftwareDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), + readSoftwareDiagnosticsAttributeListCommandParams); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo); - Map readSwitchInteractionInfo = new LinkedHashMap<>(); - Map readSwitchNumberOfPositionsCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readNumberOfPositionsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchNumberOfPositionsCommandParams - ); - readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.put("readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); - Map readSwitchAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readAttributeListAttribute( - ( ChipClusters.SwitchCluster.AttributeListAttributeCallback - ) callback - ); - }, + readSoftwareDiagnosticsFeatureMapCommandParams); + readSoftwareDiagnosticsInteractionInfo.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); + readSoftwareDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo); + Map readSwitchInteractionInfo = new LinkedHashMap<>(); + Map readSwitchNumberOfPositionsCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readNumberOfPositionsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchNumberOfPositionsCommandParams); + readSwitchInteractionInfo.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); + readSwitchInteractionInfo.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); + readSwitchInteractionInfo.put( + "readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); + Map readSwitchAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.SwitchCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedSwitchClusterAttributeListAttributeCallback(), - readSwitchAttributeListCommandParams - ); - readSwitchInteractionInfo.put("readAttributeListAttribute", readSwitchAttributeListAttributeInteractionInfo); - Map readSwitchFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSwitchAttributeListCommandParams); + readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.put("readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("switch", readSwitchInteractionInfo); - Map readTargetNavigatorInteractionInfo = new LinkedHashMap<>(); - Map readTargetNavigatorTargetNavigatorListCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorTargetNavigatorListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readTargetNavigatorListAttribute( - ( ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback(), - readTargetNavigatorTargetNavigatorListCommandParams - ); - readTargetNavigatorInteractionInfo.put("readTargetNavigatorListAttribute", readTargetNavigatorTargetNavigatorListAttributeInteractionInfo); - Map readTargetNavigatorCurrentNavigatorTargetCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readCurrentNavigatorTargetAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorCurrentNavigatorTargetCommandParams - ); - readTargetNavigatorInteractionInfo.put("readCurrentNavigatorTargetAttribute", readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo); - Map readTargetNavigatorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readAttributeListAttribute( - ( ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), - readTargetNavigatorAttributeListCommandParams - ); - readTargetNavigatorInteractionInfo.put("readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); - Map readTargetNavigatorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorClusterRevisionCommandParams - ); - readTargetNavigatorInteractionInfo.put("readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("targetNavigator", readTargetNavigatorInteractionInfo); - Map readTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readTemperatureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMeasuredValueCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readMeasuredValueAttribute", readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMinMeasuredValueCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMaxMeasuredValueCommandParams - ); - readTemperatureMeasurementInteractionInfo.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 - ); - readTemperatureMeasurementInteractionInfo.put("readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); - Map readTemperatureMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), - readTemperatureMeasurementAttributeListCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readAttributeListAttribute", readTemperatureMeasurementAttributeListAttributeInteractionInfo); - Map readTemperatureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementClusterRevisionCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readClusterRevisionAttribute", readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo); - Map readTestClusterInteractionInfo = new LinkedHashMap<>(); - Map readTestClusterBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readSwitchFeatureMapCommandParams); + readSwitchInteractionInfo.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); + readSwitchInteractionInfo.put( + "readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("switch", readSwitchInteractionInfo); + Map readTargetNavigatorInteractionInfo = new LinkedHashMap<>(); + Map readTargetNavigatorTargetNavigatorListCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorTargetNavigatorListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readTargetNavigatorListAttribute( + (ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback(), + readTargetNavigatorTargetNavigatorListCommandParams); + readTargetNavigatorInteractionInfo.put( + "readTargetNavigatorListAttribute", + readTargetNavigatorTargetNavigatorListAttributeInteractionInfo); + Map readTargetNavigatorCurrentNavigatorTargetCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readCurrentNavigatorTargetAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorCurrentNavigatorTargetCommandParams); + readTargetNavigatorInteractionInfo.put( + "readCurrentNavigatorTargetAttribute", + readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo); + Map readTargetNavigatorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), + readTargetNavigatorAttributeListCommandParams); + readTargetNavigatorInteractionInfo.put( + "readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); + Map readTargetNavigatorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorClusterRevisionCommandParams); + readTargetNavigatorInteractionInfo.put( + "readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("targetNavigator", readTargetNavigatorInteractionInfo); + Map readTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readTemperatureMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMeasuredValueCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", + readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMinMeasuredValueCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMaxMeasuredValueCommandParams); + readTemperatureMeasurementInteractionInfo.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); + readTemperatureMeasurementInteractionInfo.put( + "readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); + Map readTemperatureMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), + readTemperatureMeasurementAttributeListCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readTemperatureMeasurementAttributeListAttributeInteractionInfo); + Map readTemperatureMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementClusterRevisionCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo); + Map readTestClusterInteractionInfo = new LinkedHashMap<>(); + Map readTestClusterBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readBooleanAttribute", readTestClusterBooleanAttributeInteractionInfo); - Map readTestClusterBitmap8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap8Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterBitmap8CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap8Attribute", readTestClusterBitmap8AttributeInteractionInfo); - Map readTestClusterBitmap16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap16Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterBitmap16CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap16Attribute", readTestClusterBitmap16AttributeInteractionInfo); - Map readTestClusterBitmap32CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap32Attribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readBooleanAttribute", readTestClusterBooleanAttributeInteractionInfo); + Map readTestClusterBitmap8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap8Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterBitmap8CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap8Attribute", readTestClusterBitmap8AttributeInteractionInfo); + Map readTestClusterBitmap16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap16Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterBitmap16CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap16Attribute", readTestClusterBitmap16AttributeInteractionInfo); + Map readTestClusterBitmap32CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap32Attribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterBitmap32CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap32Attribute", readTestClusterBitmap32AttributeInteractionInfo); - Map readTestClusterBitmap64CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap64Attribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterBitmap32CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap32Attribute", readTestClusterBitmap32AttributeInteractionInfo); + Map readTestClusterBitmap64CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap64Attribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterBitmap64CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap64Attribute", readTestClusterBitmap64AttributeInteractionInfo); - Map readTestClusterInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt8uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readInt8uAttribute", readTestClusterInt8uAttributeInteractionInfo); - Map readTestClusterInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt16uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); - Map readTestClusterInt24uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt24uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterBitmap64CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap64Attribute", readTestClusterBitmap64AttributeInteractionInfo); + Map readTestClusterInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt8uAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readInt8uAttribute", readTestClusterInt8uAttributeInteractionInfo); + Map readTestClusterInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt16uAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); + Map readTestClusterInt24uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt24uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt24uCommandParams - ); - readTestClusterInteractionInfo.put("readInt24uAttribute", readTestClusterInt24uAttributeInteractionInfo); - Map readTestClusterInt32uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt32uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt24uCommandParams); + readTestClusterInteractionInfo.put( + "readInt24uAttribute", readTestClusterInt24uAttributeInteractionInfo); + Map readTestClusterInt32uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt32uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt32uCommandParams - ); - readTestClusterInteractionInfo.put("readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); - Map readTestClusterInt40uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt40uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt32uCommandParams); + readTestClusterInteractionInfo.put( + "readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); + Map readTestClusterInt40uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt40uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt40uCommandParams - ); - readTestClusterInteractionInfo.put("readInt40uAttribute", readTestClusterInt40uAttributeInteractionInfo); - Map readTestClusterInt48uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt48uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt40uCommandParams); + readTestClusterInteractionInfo.put( + "readInt40uAttribute", readTestClusterInt40uAttributeInteractionInfo); + Map readTestClusterInt48uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt48uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt48uCommandParams - ); - readTestClusterInteractionInfo.put("readInt48uAttribute", readTestClusterInt48uAttributeInteractionInfo); - Map readTestClusterInt56uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt56uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt48uCommandParams); + readTestClusterInteractionInfo.put( + "readInt48uAttribute", readTestClusterInt48uAttributeInteractionInfo); + Map readTestClusterInt56uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt56uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt56uCommandParams - ); - readTestClusterInteractionInfo.put("readInt56uAttribute", readTestClusterInt56uAttributeInteractionInfo); - Map readTestClusterInt64uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt64uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt56uCommandParams); + readTestClusterInteractionInfo.put( + "readInt56uAttribute", readTestClusterInt56uAttributeInteractionInfo); + Map readTestClusterInt64uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt64uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt64uCommandParams - ); - readTestClusterInteractionInfo.put("readInt64uAttribute", readTestClusterInt64uAttributeInteractionInfo); - Map readTestClusterInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt8sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readInt8sAttribute", readTestClusterInt8sAttributeInteractionInfo); - Map readTestClusterInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt16sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); - Map readTestClusterInt24sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt24sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt64uCommandParams); + readTestClusterInteractionInfo.put( + "readInt64uAttribute", readTestClusterInt64uAttributeInteractionInfo); + Map readTestClusterInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt8sAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readInt8sAttribute", readTestClusterInt8sAttributeInteractionInfo); + Map readTestClusterInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt16sAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); + Map readTestClusterInt24sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt24sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt24sCommandParams - ); - readTestClusterInteractionInfo.put("readInt24sAttribute", readTestClusterInt24sAttributeInteractionInfo); - Map readTestClusterInt32sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt32sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt24sCommandParams); + readTestClusterInteractionInfo.put( + "readInt24sAttribute", readTestClusterInt24sAttributeInteractionInfo); + Map readTestClusterInt32sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt32sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt32sCommandParams - ); - readTestClusterInteractionInfo.put("readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); - Map readTestClusterInt40sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt40sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt32sCommandParams); + readTestClusterInteractionInfo.put( + "readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); + Map readTestClusterInt40sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt40sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt40sCommandParams - ); - readTestClusterInteractionInfo.put("readInt40sAttribute", readTestClusterInt40sAttributeInteractionInfo); - Map readTestClusterInt48sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt48sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt40sCommandParams); + readTestClusterInteractionInfo.put( + "readInt40sAttribute", readTestClusterInt40sAttributeInteractionInfo); + Map readTestClusterInt48sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt48sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt48sCommandParams - ); - readTestClusterInteractionInfo.put("readInt48sAttribute", readTestClusterInt48sAttributeInteractionInfo); - Map readTestClusterInt56sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt56sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt48sCommandParams); + readTestClusterInteractionInfo.put( + "readInt48sAttribute", readTestClusterInt48sAttributeInteractionInfo); + Map readTestClusterInt56sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt56sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt56sCommandParams - ); - readTestClusterInteractionInfo.put("readInt56sAttribute", readTestClusterInt56sAttributeInteractionInfo); - Map readTestClusterInt64sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt64sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt56sCommandParams); + readTestClusterInteractionInfo.put( + "readInt56sAttribute", readTestClusterInt56sAttributeInteractionInfo); + Map readTestClusterInt64sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt64sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt64sCommandParams - ); - readTestClusterInteractionInfo.put("readInt64sAttribute", readTestClusterInt64sAttributeInteractionInfo); - Map readTestClusterEnum8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEnum8Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnum8CommandParams - ); - readTestClusterInteractionInfo.put("readEnum8Attribute", readTestClusterEnum8AttributeInteractionInfo); - Map readTestClusterEnum16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEnum16Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnum16CommandParams - ); - readTestClusterInteractionInfo.put("readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); - Map readTestClusterFloatSingleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readFloatSingleAttribute( - ( - ChipClusters.FloatAttributeCallback -) callback - ); - }, + readTestClusterInt64sCommandParams); + readTestClusterInteractionInfo.put( + "readInt64sAttribute", readTestClusterInt64sAttributeInteractionInfo); + Map readTestClusterEnum8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEnum8Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnum8CommandParams); + readTestClusterInteractionInfo.put( + "readEnum8Attribute", readTestClusterEnum8AttributeInteractionInfo); + Map readTestClusterEnum16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEnum16Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnum16CommandParams); + readTestClusterInteractionInfo.put( + "readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); + Map readTestClusterFloatSingleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readFloatSingleAttribute((ChipClusters.FloatAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readTestClusterFloatSingleCommandParams - ); - readTestClusterInteractionInfo.put("readFloatSingleAttribute", readTestClusterFloatSingleAttributeInteractionInfo); - Map readTestClusterFloatDoubleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readFloatDoubleAttribute( - ( - ChipClusters.DoubleAttributeCallback -) callback - ); - }, + readTestClusterFloatSingleCommandParams); + readTestClusterInteractionInfo.put( + "readFloatSingleAttribute", readTestClusterFloatSingleAttributeInteractionInfo); + Map readTestClusterFloatDoubleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readFloatDoubleAttribute((ChipClusters.DoubleAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readTestClusterFloatDoubleCommandParams - ); - readTestClusterInteractionInfo.put("readFloatDoubleAttribute", readTestClusterFloatDoubleAttributeInteractionInfo); - Map readTestClusterOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readOctetStringAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readTestClusterFloatDoubleCommandParams); + readTestClusterInteractionInfo.put( + "readFloatDoubleAttribute", readTestClusterFloatDoubleAttributeInteractionInfo); + Map readTestClusterOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readOctetStringAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readOctetStringAttribute", readTestClusterOctetStringAttributeInteractionInfo); - Map readTestClusterListInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListInt8uAttribute( - ( ChipClusters.TestClusterCluster.ListInt8uAttributeCallback - ) callback - ); - }, + readTestClusterOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readOctetStringAttribute", readTestClusterOctetStringAttributeInteractionInfo); + Map readTestClusterListInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListInt8uAttribute( + (ChipClusters.TestClusterCluster.ListInt8uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedTestClusterClusterListInt8uAttributeCallback(), - readTestClusterListInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readListInt8uAttribute", readTestClusterListInt8uAttributeInteractionInfo); - Map readTestClusterListOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListOctetStringAttribute( - ( ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListOctetStringAttributeCallback(), - readTestClusterListOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readListOctetStringAttribute", readTestClusterListOctetStringAttributeInteractionInfo); - Map readTestClusterListStructOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListStructOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListStructOctetStringAttribute( - ( ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListStructOctetStringAttributeCallback(), - readTestClusterListStructOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readListStructOctetStringAttribute", readTestClusterListStructOctetStringAttributeInteractionInfo); - Map readTestClusterLongOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readLongOctetStringAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readTestClusterListInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readListInt8uAttribute", readTestClusterListInt8uAttributeInteractionInfo); + Map readTestClusterListOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListOctetStringAttribute( + (ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListOctetStringAttributeCallback(), + readTestClusterListOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readListOctetStringAttribute", readTestClusterListOctetStringAttributeInteractionInfo); + Map readTestClusterListStructOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListStructOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListStructOctetStringAttribute( + (ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListStructOctetStringAttributeCallback(), + readTestClusterListStructOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readListStructOctetStringAttribute", + readTestClusterListStructOctetStringAttributeInteractionInfo); + Map readTestClusterLongOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readLongOctetStringAttribute( + (ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterLongOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeInteractionInfo); - Map readTestClusterCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readCharStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readTestClusterLongOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeInteractionInfo); + Map readTestClusterCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterCharStringCommandParams - ); - readTestClusterInteractionInfo.put("readCharStringAttribute", readTestClusterCharStringAttributeInteractionInfo); - Map readTestClusterLongCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterLongCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readLongCharStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readTestClusterCharStringCommandParams); + readTestClusterInteractionInfo.put( + "readCharStringAttribute", readTestClusterCharStringAttributeInteractionInfo); + Map readTestClusterLongCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterLongCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readLongCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterLongCharStringCommandParams - ); - readTestClusterInteractionInfo.put("readLongCharStringAttribute", readTestClusterLongCharStringAttributeInteractionInfo); - Map readTestClusterEpochUsCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEpochUsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEpochUsAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterLongCharStringCommandParams); + readTestClusterInteractionInfo.put( + "readLongCharStringAttribute", readTestClusterLongCharStringAttributeInteractionInfo); + Map readTestClusterEpochUsCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEpochUsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEpochUsAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterEpochUsCommandParams - ); - readTestClusterInteractionInfo.put("readEpochUsAttribute", readTestClusterEpochUsAttributeInteractionInfo); - Map readTestClusterEpochSCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEpochSAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEpochSAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterEpochUsCommandParams); + readTestClusterInteractionInfo.put( + "readEpochUsAttribute", readTestClusterEpochUsAttributeInteractionInfo); + Map readTestClusterEpochSCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEpochSAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEpochSAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterEpochSCommandParams - ); - readTestClusterInteractionInfo.put("readEpochSAttribute", readTestClusterEpochSAttributeInteractionInfo); - Map readTestClusterVendorIdCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readVendorIdAttribute( - ( ChipClusters.TestClusterCluster.VendorIdAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterVendorIdCommandParams - ); - readTestClusterInteractionInfo.put("readVendorIdAttribute", readTestClusterVendorIdAttributeInteractionInfo); - Map readTestClusterListNullablesAndOptionalsStructCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListNullablesAndOptionalsStructAttribute( - ( ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback(), - readTestClusterListNullablesAndOptionalsStructCommandParams - ); - readTestClusterInteractionInfo.put("readListNullablesAndOptionalsStructAttribute", readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); - Map readTestClusterEnumAttrCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEnumAttrAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnumAttrCommandParams - ); - readTestClusterInteractionInfo.put("readEnumAttrAttribute", readTestClusterEnumAttrAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt8uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt8uAttribute", readTestClusterRangeRestrictedInt8uAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt8sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt8sAttribute", readTestClusterRangeRestrictedInt8sAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt16uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt16uAttribute", readTestClusterRangeRestrictedInt16uAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt16sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt16sAttribute", readTestClusterRangeRestrictedInt16sAttributeInteractionInfo); - Map readTestClusterListLongOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListLongOctetStringAttribute( - ( ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListLongOctetStringAttributeCallback(), - readTestClusterListLongOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readListLongOctetStringAttribute", readTestClusterListLongOctetStringAttributeInteractionInfo); - Map readTestClusterTimedWriteBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readTimedWriteBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterEpochSCommandParams); + readTestClusterInteractionInfo.put( + "readEpochSAttribute", readTestClusterEpochSAttributeInteractionInfo); + Map readTestClusterVendorIdCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readVendorIdAttribute( + (ChipClusters.TestClusterCluster.VendorIdAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterVendorIdCommandParams); + readTestClusterInteractionInfo.put( + "readVendorIdAttribute", readTestClusterVendorIdAttributeInteractionInfo); + Map readTestClusterListNullablesAndOptionalsStructCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListNullablesAndOptionalsStructAttribute( + (ChipClusters.TestClusterCluster + .ListNullablesAndOptionalsStructAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback(), + readTestClusterListNullablesAndOptionalsStructCommandParams); + readTestClusterInteractionInfo.put( + "readListNullablesAndOptionalsStructAttribute", + readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); + Map readTestClusterEnumAttrCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEnumAttrAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnumAttrCommandParams); + readTestClusterInteractionInfo.put( + "readEnumAttrAttribute", readTestClusterEnumAttrAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt8uAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt8uAttribute", + readTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt8sAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt8sAttribute", + readTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt16uAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt16uAttribute", + readTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt16sAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt16sAttribute", + readTestClusterRangeRestrictedInt16sAttributeInteractionInfo); + Map readTestClusterListLongOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListLongOctetStringAttribute( + (ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListLongOctetStringAttributeCallback(), + readTestClusterListLongOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readListLongOctetStringAttribute", + readTestClusterListLongOctetStringAttributeInteractionInfo); + Map readTestClusterTimedWriteBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterTimedWriteBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readTimedWriteBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterTimedWriteBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readTimedWriteBooleanAttribute", readTestClusterTimedWriteBooleanAttributeInteractionInfo); - Map readTestClusterGeneralErrorBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readGeneralErrorBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterTimedWriteBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readTimedWriteBooleanAttribute", readTestClusterTimedWriteBooleanAttributeInteractionInfo); + Map readTestClusterGeneralErrorBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterGeneralErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readGeneralErrorBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterGeneralErrorBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readGeneralErrorBooleanAttribute", readTestClusterGeneralErrorBooleanAttributeInteractionInfo); - Map readTestClusterClusterErrorBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readClusterErrorBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterGeneralErrorBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readGeneralErrorBooleanAttribute", + readTestClusterGeneralErrorBooleanAttributeInteractionInfo); + Map readTestClusterClusterErrorBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterClusterErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readClusterErrorBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterClusterErrorBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readClusterErrorBooleanAttribute", readTestClusterClusterErrorBooleanAttributeInteractionInfo); - Map readTestClusterUnsupportedCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readUnsupportedAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterClusterErrorBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readClusterErrorBooleanAttribute", + readTestClusterClusterErrorBooleanAttributeInteractionInfo); + Map readTestClusterUnsupportedCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readUnsupportedAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterUnsupportedCommandParams - ); - readTestClusterInteractionInfo.put("readUnsupportedAttribute", readTestClusterUnsupportedAttributeInteractionInfo); - Map readTestClusterNullableBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBooleanAttribute( - ( ChipClusters.TestClusterCluster.NullableBooleanAttributeCallback - ) callback - ); - }, + readTestClusterUnsupportedCommandParams); + readTestClusterInteractionInfo.put( + "readUnsupportedAttribute", readTestClusterUnsupportedAttributeInteractionInfo); + Map readTestClusterNullableBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBooleanAttribute( + (ChipClusters.TestClusterCluster.NullableBooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterNullableBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeInteractionInfo); - Map readTestClusterNullableBitmap8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap8Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap8AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableBitmap8CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeInteractionInfo); - Map readTestClusterNullableBitmap16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap16Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap16AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableBitmap16CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeInteractionInfo); - Map readTestClusterNullableBitmap32CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap32Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap32AttributeCallback - ) callback - ); - }, + readTestClusterNullableBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeInteractionInfo); + Map readTestClusterNullableBitmap8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap8Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap8AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableBitmap8CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeInteractionInfo); + Map readTestClusterNullableBitmap16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap16Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap16AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableBitmap16CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeInteractionInfo); + Map readTestClusterNullableBitmap32CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap32Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap32AttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableBitmap32CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeInteractionInfo); - Map readTestClusterNullableBitmap64CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap64Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap64AttributeCallback - ) callback - ); - }, + readTestClusterNullableBitmap32CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeInteractionInfo); + Map readTestClusterNullableBitmap64CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap64Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap64AttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableBitmap64CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeInteractionInfo); - Map readTestClusterNullableInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt8uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt8uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeInteractionInfo); - Map readTestClusterNullableInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt16uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt16uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); - Map readTestClusterNullableInt24uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt24uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt24uAttributeCallback - ) callback - ); - }, + readTestClusterNullableBitmap64CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeInteractionInfo); + Map readTestClusterNullableInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt8uAttribute( + (ChipClusters.TestClusterCluster.NullableInt8uAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeInteractionInfo); + Map readTestClusterNullableInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt16uAttribute( + (ChipClusters.TestClusterCluster.NullableInt16uAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); + Map readTestClusterNullableInt24uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt24uAttribute( + (ChipClusters.TestClusterCluster.NullableInt24uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt24uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt24uAttribute", readTestClusterNullableInt24uAttributeInteractionInfo); - Map readTestClusterNullableInt32uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt32uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt32uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt24uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt24uAttribute", readTestClusterNullableInt24uAttributeInteractionInfo); + Map readTestClusterNullableInt32uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt32uAttribute( + (ChipClusters.TestClusterCluster.NullableInt32uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt32uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); - Map readTestClusterNullableInt40uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt40uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt40uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt32uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); + Map readTestClusterNullableInt40uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt40uAttribute( + (ChipClusters.TestClusterCluster.NullableInt40uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt40uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt40uAttribute", readTestClusterNullableInt40uAttributeInteractionInfo); - Map readTestClusterNullableInt48uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt48uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt48uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt40uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt40uAttribute", readTestClusterNullableInt40uAttributeInteractionInfo); + Map readTestClusterNullableInt48uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt48uAttribute( + (ChipClusters.TestClusterCluster.NullableInt48uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt48uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt48uAttribute", readTestClusterNullableInt48uAttributeInteractionInfo); - Map readTestClusterNullableInt56uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt56uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt56uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt48uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt48uAttribute", readTestClusterNullableInt48uAttributeInteractionInfo); + Map readTestClusterNullableInt56uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt56uAttribute( + (ChipClusters.TestClusterCluster.NullableInt56uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt56uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt56uAttribute", readTestClusterNullableInt56uAttributeInteractionInfo); - Map readTestClusterNullableInt64uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt64uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt64uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt56uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt56uAttribute", readTestClusterNullableInt56uAttributeInteractionInfo); + Map readTestClusterNullableInt64uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt64uAttribute( + (ChipClusters.TestClusterCluster.NullableInt64uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt64uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeInteractionInfo); - Map readTestClusterNullableInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt8sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt8sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeInteractionInfo); - Map readTestClusterNullableInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt16sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt16sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); - Map readTestClusterNullableInt24sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt24sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt24sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt64uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeInteractionInfo); + Map readTestClusterNullableInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt8sAttribute( + (ChipClusters.TestClusterCluster.NullableInt8sAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeInteractionInfo); + Map readTestClusterNullableInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt16sAttribute( + (ChipClusters.TestClusterCluster.NullableInt16sAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); + Map readTestClusterNullableInt24sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt24sAttribute( + (ChipClusters.TestClusterCluster.NullableInt24sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt24sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt24sAttribute", readTestClusterNullableInt24sAttributeInteractionInfo); - Map readTestClusterNullableInt32sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt32sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt32sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt24sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt24sAttribute", readTestClusterNullableInt24sAttributeInteractionInfo); + Map readTestClusterNullableInt32sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt32sAttribute( + (ChipClusters.TestClusterCluster.NullableInt32sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt32sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); - Map readTestClusterNullableInt40sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt40sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt40sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt32sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); + Map readTestClusterNullableInt40sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt40sAttribute( + (ChipClusters.TestClusterCluster.NullableInt40sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt40sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt40sAttribute", readTestClusterNullableInt40sAttributeInteractionInfo); - Map readTestClusterNullableInt48sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt48sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt48sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt40sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt40sAttribute", readTestClusterNullableInt40sAttributeInteractionInfo); + Map readTestClusterNullableInt48sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt48sAttribute( + (ChipClusters.TestClusterCluster.NullableInt48sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt48sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt48sAttribute", readTestClusterNullableInt48sAttributeInteractionInfo); - Map readTestClusterNullableInt56sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt56sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt56sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt48sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt48sAttribute", readTestClusterNullableInt48sAttributeInteractionInfo); + Map readTestClusterNullableInt56sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt56sAttribute( + (ChipClusters.TestClusterCluster.NullableInt56sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt56sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt56sAttribute", readTestClusterNullableInt56sAttributeInteractionInfo); - Map readTestClusterNullableInt64sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt64sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt64sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt56sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt56sAttribute", readTestClusterNullableInt56sAttributeInteractionInfo); + Map readTestClusterNullableInt64sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt64sAttribute( + (ChipClusters.TestClusterCluster.NullableInt64sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt64sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeInteractionInfo); - Map readTestClusterNullableEnum8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableEnum8Attribute( - ( ChipClusters.TestClusterCluster.NullableEnum8AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnum8CommandParams - ); - readTestClusterInteractionInfo.put("readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeInteractionInfo); - Map readTestClusterNullableEnum16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableEnum16Attribute( - ( ChipClusters.TestClusterCluster.NullableEnum16AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnum16CommandParams - ); - readTestClusterInteractionInfo.put("readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); - Map readTestClusterNullableFloatSingleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableFloatSingleAttribute( - ( ChipClusters.TestClusterCluster.NullableFloatSingleAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt64sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeInteractionInfo); + Map readTestClusterNullableEnum8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableEnum8Attribute( + (ChipClusters.TestClusterCluster.NullableEnum8AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnum8CommandParams); + readTestClusterInteractionInfo.put( + "readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeInteractionInfo); + Map readTestClusterNullableEnum16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableEnum16Attribute( + (ChipClusters.TestClusterCluster.NullableEnum16AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnum16CommandParams); + readTestClusterInteractionInfo.put( + "readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); + Map readTestClusterNullableFloatSingleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableFloatSingleAttribute( + (ChipClusters.TestClusterCluster.NullableFloatSingleAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readTestClusterNullableFloatSingleCommandParams - ); - readTestClusterInteractionInfo.put("readNullableFloatSingleAttribute", readTestClusterNullableFloatSingleAttributeInteractionInfo); - Map readTestClusterNullableFloatDoubleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableFloatDoubleAttribute( - ( ChipClusters.TestClusterCluster.NullableFloatDoubleAttributeCallback - ) callback - ); - }, + readTestClusterNullableFloatSingleCommandParams); + readTestClusterInteractionInfo.put( + "readNullableFloatSingleAttribute", + readTestClusterNullableFloatSingleAttributeInteractionInfo); + Map readTestClusterNullableFloatDoubleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableFloatDoubleAttribute( + (ChipClusters.TestClusterCluster.NullableFloatDoubleAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readTestClusterNullableFloatDoubleCommandParams - ); - readTestClusterInteractionInfo.put("readNullableFloatDoubleAttribute", readTestClusterNullableFloatDoubleAttributeInteractionInfo); - Map readTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableOctetStringAttribute( - ( ChipClusters.TestClusterCluster.NullableOctetStringAttributeCallback - ) callback - ); - }, + readTestClusterNullableFloatDoubleCommandParams); + readTestClusterInteractionInfo.put( + "readNullableFloatDoubleAttribute", + readTestClusterNullableFloatDoubleAttributeInteractionInfo); + Map readTestClusterNullableOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableOctetStringAttribute( + (ChipClusters.TestClusterCluster.NullableOctetStringAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterNullableOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readNullableOctetStringAttribute", readTestClusterNullableOctetStringAttributeInteractionInfo); - Map readTestClusterNullableCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableCharStringAttribute( - ( ChipClusters.TestClusterCluster.NullableCharStringAttributeCallback - ) callback - ); - }, + readTestClusterNullableOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readNullableOctetStringAttribute", + readTestClusterNullableOctetStringAttributeInteractionInfo); + Map readTestClusterNullableCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableCharStringAttribute( + (ChipClusters.TestClusterCluster.NullableCharStringAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterNullableCharStringCommandParams - ); - readTestClusterInteractionInfo.put("readNullableCharStringAttribute", readTestClusterNullableCharStringAttributeInteractionInfo); - Map readTestClusterNullableEnumAttrCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableEnumAttrAttribute( - ( ChipClusters.TestClusterCluster.NullableEnumAttrAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnumAttrCommandParams - ); - readTestClusterInteractionInfo.put("readNullableEnumAttrAttribute", readTestClusterNullableEnumAttrAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt8uAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt8uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt8uAttribute", readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt8sAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt8sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt8sAttribute", readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt16uAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt16uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt16uAttribute", readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt16sAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt16sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt16sAttribute", readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); - Map readTestClusterAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readAttributeListAttribute( - ( ChipClusters.TestClusterCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterAttributeListAttributeCallback(), - readTestClusterAttributeListCommandParams - ); - readTestClusterInteractionInfo.put("readAttributeListAttribute", readTestClusterAttributeListAttributeInteractionInfo); - Map readTestClusterClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterClusterRevisionCommandParams - ); - readTestClusterInteractionInfo.put("readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("testCluster", readTestClusterInteractionInfo); - Map readThermostatInteractionInfo = new LinkedHashMap<>(); - Map readThermostatLocalTemperatureCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readLocalTemperatureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatLocalTemperatureCommandParams - ); - readThermostatInteractionInfo.put("readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); - Map readThermostatAbsMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAbsMinHeatSetpointLimitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMinHeatSetpointLimitCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readAbsMaxCoolSetpointLimitAttribute", readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readOccupiedCoolingSetpointAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatOccupiedCoolingSetpointCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readOccupiedHeatingSetpointAttribute", readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); - Map readThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readMinHeatSetpointLimitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMinHeatSetpointLimitCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readMinSetpointDeadBandAttribute", readThermostatMinSetpointDeadBandAttributeInteractionInfo); - Map readThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readControlSequenceOfOperationAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatControlSequenceOfOperationCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); - Map readThermostatStartOfWeekCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readStartOfWeekAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatStartOfWeekCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readNumberOfDailyTransitionsAttribute", readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); - Map readThermostatAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ThermostatCluster.AttributeListAttributeCallback - ) callback - ); - }, + readTestClusterNullableCharStringCommandParams); + readTestClusterInteractionInfo.put( + "readNullableCharStringAttribute", + readTestClusterNullableCharStringAttributeInteractionInfo); + Map readTestClusterNullableEnumAttrCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableEnumAttrAttribute( + (ChipClusters.TestClusterCluster.NullableEnumAttrAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnumAttrCommandParams); + readTestClusterInteractionInfo.put( + "readNullableEnumAttrAttribute", readTestClusterNullableEnumAttrAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt8uAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt8uAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt8uAttribute", + readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt8sAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt8sAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt8sAttribute", + readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt16uAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt16uAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt16uAttribute", + readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt16sAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt16sAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt16sAttribute", + readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); + Map readTestClusterAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TestClusterCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedTestClusterClusterAttributeListAttributeCallback(), + readTestClusterAttributeListCommandParams); + readTestClusterInteractionInfo.put( + "readAttributeListAttribute", readTestClusterAttributeListAttributeInteractionInfo); + Map readTestClusterClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterClusterRevisionCommandParams); + readTestClusterInteractionInfo.put( + "readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("testCluster", readTestClusterInteractionInfo); + Map readThermostatInteractionInfo = new LinkedHashMap<>(); + Map readThermostatLocalTemperatureCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readLocalTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatLocalTemperatureCommandParams); + readThermostatInteractionInfo.put( + "readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); + Map readThermostatAbsMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAbsMinHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMinHeatSetpointLimitCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readAbsMaxCoolSetpointLimitAttribute", + readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatOccupiedCoolingSetpointCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readOccupiedCoolingSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatOccupiedCoolingSetpointCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readOccupiedHeatingSetpointAttribute", + readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); + Map readThermostatMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readMinHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMinHeatSetpointLimitCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readMinSetpointDeadBandAttribute", + readThermostatMinSetpointDeadBandAttributeInteractionInfo); + Map readThermostatControlSequenceOfOperationCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readControlSequenceOfOperationAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatControlSequenceOfOperationCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); + Map readThermostatStartOfWeekCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readStartOfWeekAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatStartOfWeekCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readNumberOfDailyTransitionsAttribute", + readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); + Map readThermostatAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThermostatCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedThermostatClusterAttributeListAttributeCallback(), - readThermostatAttributeListCommandParams - ); - readThermostatInteractionInfo.put("readAttributeListAttribute", readThermostatAttributeListAttributeInteractionInfo); - Map readThermostatFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThermostatAttributeListCommandParams); + readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("thermostat", readThermostatInteractionInfo); - Map readThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); - Map readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readTemperatureDisplayModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams - ); - readThermostatUserInterfaceConfigurationInteractionInfo.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 - ); - readThermostatUserInterfaceConfigurationInteractionInfo.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 - ); - readThermostatUserInterfaceConfigurationInteractionInfo.put("readScheduleProgrammingVisibilityAttribute", readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ThermostatUserInterfaceConfigurationCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), - readThermostatUserInterfaceConfigurationAttributeListCommandParams - ); - readThermostatUserInterfaceConfigurationInteractionInfo.put("readAttributeListAttribute", readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationClusterRevisionCommandParams - ); - readThermostatUserInterfaceConfigurationInteractionInfo.put("readClusterRevisionAttribute", readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("thermostatUserInterfaceConfiguration", readThermostatUserInterfaceConfigurationInteractionInfo); - Map readThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - Map readThreadNetworkDiagnosticsChannelCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsChannelCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRoutingRoleAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsRoutingRoleCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRoutingRoleAttribute", readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNetworkNameCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNetworkNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readThermostatFeatureMapCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("thermostat", readThermostatInteractionInfo); + Map readThermostatUserInterfaceConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = + new LinkedHashMap(); + InteractionInfo + readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readTemperatureDisplayModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams); + readThermostatUserInterfaceConfigurationInteractionInfo.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); + readThermostatUserInterfaceConfigurationInteractionInfo.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); + readThermostatUserInterfaceConfigurationInteractionInfo.put( + "readScheduleProgrammingVisibilityAttribute", + readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThermostatUserInterfaceConfigurationCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), + readThermostatUserInterfaceConfigurationAttributeListCommandParams); + readThermostatUserInterfaceConfigurationInteractionInfo.put( + "readAttributeListAttribute", + readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo + readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams); + readThermostatUserInterfaceConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "thermostatUserInterfaceConfiguration", + readThermostatUserInterfaceConfigurationInteractionInfo); + Map readThreadNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + Map readThreadNetworkDiagnosticsChannelCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readChannelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsChannelCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRoutingRoleAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsRoutingRoleCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRoutingRoleAttribute", + readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNetworkNameCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readNetworkNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readThreadNetworkDiagnosticsNetworkNameCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readNetworkNameAttribute", readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPanIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPanIdAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsPanIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readExtendedPanIdAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsNetworkNameCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readNetworkNameAttribute", + readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPanIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPanIdAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsPanIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readExtendedPanIdAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsExtendedPanIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readExtendedPanIdAttribute", readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readMeshLocalPrefixAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsExtendedPanIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readExtendedPanIdAttribute", + readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readMeshLocalPrefixAttribute( + (ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readMeshLocalPrefixAttribute", readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNeighborTableListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNeighborTableListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback(), - readThreadNetworkDiagnosticsNeighborTableListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readNeighborTableListAttribute", readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRouteTableListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRouteTableListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback(), - readThreadNetworkDiagnosticsRouteTableListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRouteTableListAttribute", readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPartitionIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPartitionIdAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsOverrunCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readOverrunCountAttribute", + readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNeighborTableListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readNeighborTableListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .NeighborTableListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback(), + readThreadNetworkDiagnosticsNeighborTableListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readNeighborTableListAttribute", + readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRouteTableListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRouteTableListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback(), + readThreadNetworkDiagnosticsRouteTableListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRouteTableListAttribute", + readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPartitionIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPartitionIdAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsPartitionIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readPartitionIdAttribute", readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsWeightingCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readWeightingAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsWeightingCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDataVersionCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDataVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsDataVersionCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readDataVersionAttribute", readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readStableDataVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsStableDataVersionCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readStableDataVersionAttribute", readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readLeaderRouterIdAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsLeaderRouterIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readParentChangeCountAttribute", readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxTotalCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxTotalCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsPartitionIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readPartitionIdAttribute", + readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsWeightingCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readWeightingAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsWeightingCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDataVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsDataVersionCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readDataVersionAttribute", + readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readStableDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsStableDataVersionCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readStableDataVersionAttribute", + readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readLeaderRouterIdAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsLeaderRouterIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxTotalCountAttribute", readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxUnicastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxUnicastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxTotalCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxUnicastCountAttribute", readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBroadcastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBroadcastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxUnicastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxBroadcastCountAttribute", readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxAckRequestedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxBroadcastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxAckRequestedCountAttribute", readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxAckedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxAckedCountAttribute", readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxNoAckRequestedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxAckedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxNoAckRequestedCountAttribute", readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDataCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxDataCountAttribute", readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataPollCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDataPollCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxDataCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxDataPollCountAttribute", readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBeaconCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBeaconCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxDataPollCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxBeaconCountAttribute", readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBeaconRequestCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxBeaconCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxOtherCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxOtherCountAttribute", readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxRetryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxRetryCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxOtherCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxRetryCountAttribute", readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDirectMaxRetryExpiryCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxRetryCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxIndirectMaxRetryExpiryCountAttribute", + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrCcaCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxDirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxIndirectMaxRetryExpiryCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxErrCcaCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxErrCcaCountAttribute", + readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrAbortCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxIndirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrCcaCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxErrAbortCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxErrAbortCountAttribute", + readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrBusyChannelCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrCcaCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrCcaCountAttribute", readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrAbortCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxErrBusyChannelCountAttribute", + readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrAbortCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrAbortCountAttribute", readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrBusyChannelCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxTotalCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxTotalCountAttribute", + readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrBusyChannelCountAttribute", readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxTotalCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxUnicastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxUnicastCountAttribute", + readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxTotalCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxTotalCountAttribute", readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxUnicastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxBroadcastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxBroadcastCountAttribute", + readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxUnicastCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxUnicastCountAttribute", readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBroadcastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDataCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDataCountAttribute", + readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBroadcastCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxBroadcastCountAttribute", readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDataPollCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDataPollCountAttribute", + readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDataCountAttribute", readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataPollCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxBeaconCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxBeaconCountAttribute", + readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataPollCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDataPollCountAttribute", readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxBeaconRequestCountAttribute", + readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxBeaconCountAttribute", readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconRequestCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxOtherCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxOtherCountAttribute", + readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxAddressFilteredCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxOtherCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxAddressFilteredCountAttribute", + readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDestAddrFilteredCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxOtherCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxOtherCountAttribute", readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxAddressFilteredCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDestAddrFilteredCountAttribute", + readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDuplicatedCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxAddressFilteredCountAttribute", readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDestAddrFilteredCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDuplicatedCountAttribute", + readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrNoFrameCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDestAddrFilteredCountAttribute", readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDuplicatedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrNoFrameCountAttribute", + readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrUnknownNeighborCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDuplicatedCountAttribute", readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrNoFrameCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrUnknownNeighborCountAttribute", + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrInvalidSrcAddrCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrNoFrameCountAttribute", readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrUnknownNeighborCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrInvalidSrcAddrCountAttribute", + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrSecCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrUnknownNeighborCountAttribute", readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrInvalidSrcAddrCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrSecCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrSecCountAttribute", + readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrFcsCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrInvalidSrcAddrCountAttribute", readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrSecCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrFcsCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrFcsCountAttribute", + readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrSecCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrSecCountAttribute", readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrFcsCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrOtherCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrOtherCountAttribute", + readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readActiveTimestampAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrFcsCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrFcsCountAttribute", readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrOtherCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsActiveTimestampCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readActiveTimestampAttribute", + readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPendingTimestampAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrOtherCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrOtherCountAttribute", readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveTimestampAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsPendingTimestampCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readPendingTimestampAttribute", + readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDelayCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readDelayAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsActiveTimestampCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readActiveTimestampAttribute", readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPendingTimestampAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsPendingTimestampCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readPendingTimestampAttribute", readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDelayCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDelayAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsDelayCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsSecurityPolicyCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readSecurityPolicyAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback(), - readThreadNetworkDiagnosticsSecurityPolicyCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readSecurityPolicyAttribute", readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsChannelMaskCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelMaskAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsDelayCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsSecurityPolicyCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readSecurityPolicyAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback(), + readThreadNetworkDiagnosticsSecurityPolicyCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readSecurityPolicyAttribute", + readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsChannelMaskCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readChannelMaskAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readThreadNetworkDiagnosticsChannelMaskCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readChannelMaskAttribute", readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readOperationalDatasetComponentsAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.OperationalDatasetComponentsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback(), - readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readOperationalDatasetComponentsAttribute", readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveNetworkFaultsListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), - readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readActiveNetworkFaultsListAttribute", readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readThreadNetworkDiagnosticsAttributeListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readAttributeListAttribute", readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsChannelMaskCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readChannelMaskAttribute", + readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams = + new LinkedHashMap(); + InteractionInfo + readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readOperationalDatasetComponentsAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .OperationalDatasetComponentsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback(), + readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readOperationalDatasetComponentsAttribute", + readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readActiveNetworkFaultsListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .ActiveNetworkFaultsListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), + readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readActiveNetworkFaultsListAttribute", + readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readThreadNetworkDiagnosticsAttributeListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo); - Map readTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map readTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readHourFormatAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationHourFormatCommandParams - ); - readTimeFormatLocalizationInteractionInfo.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 - ); - readTimeFormatLocalizationInteractionInfo.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 - ); - readTimeFormatLocalizationInteractionInfo.put("readSupportedCalendarTypesAttribute", readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); - Map readTimeFormatLocalizationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationClusterRevisionCommandParams - ); - readTimeFormatLocalizationInteractionInfo.put("readClusterRevisionAttribute", readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo); - Map readUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map readUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readTemperatureUnitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitLocalizationTemperatureUnitCommandParams - ); - readUnitLocalizationInteractionInfo.put("readTemperatureUnitAttribute", readUnitLocalizationTemperatureUnitAttributeInteractionInfo); - Map readUnitLocalizationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsFeatureMapCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo); + Map readTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); + Map readTimeFormatLocalizationHourFormatCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readHourFormatAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationHourFormatCommandParams); + readTimeFormatLocalizationInteractionInfo.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); + readTimeFormatLocalizationInteractionInfo.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); + readTimeFormatLocalizationInteractionInfo.put( + "readSupportedCalendarTypesAttribute", + readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); + Map readTimeFormatLocalizationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationClusterRevisionCommandParams); + readTimeFormatLocalizationInteractionInfo.put( + "readClusterRevisionAttribute", + readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo); + Map readUnitLocalizationInteractionInfo = new LinkedHashMap<>(); + Map readUnitLocalizationTemperatureUnitCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readTemperatureUnitAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitLocalizationTemperatureUnitCommandParams); + readUnitLocalizationInteractionInfo.put( + "readTemperatureUnitAttribute", + readUnitLocalizationTemperatureUnitAttributeInteractionInfo); + Map readUnitLocalizationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitLocalizationFeatureMapCommandParams - ); - readUnitLocalizationInteractionInfo.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 - ); - readUnitLocalizationInteractionInfo.put("readClusterRevisionAttribute", readUnitLocalizationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("unitLocalization", readUnitLocalizationInteractionInfo); - Map readUserLabelInteractionInfo = new LinkedHashMap<>(); - Map readUserLabelLabelListCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelLabelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readLabelListAttribute( - ( ChipClusters.UserLabelCluster.LabelListAttributeCallback - ) callback - ); - }, + readUnitLocalizationFeatureMapCommandParams); + readUnitLocalizationInteractionInfo.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); + readUnitLocalizationInteractionInfo.put( + "readClusterRevisionAttribute", + readUnitLocalizationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("unitLocalization", readUnitLocalizationInteractionInfo); + Map readUserLabelInteractionInfo = 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 - ); - readUserLabelInteractionInfo.put("readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); - Map readUserLabelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUserLabelClusterRevisionCommandParams - ); - readUserLabelInteractionInfo.put("readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("userLabel", readUserLabelInteractionInfo); - Map readWakeOnLanInteractionInfo = new LinkedHashMap<>(); - Map readWakeOnLanWakeOnLanMacAddressCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readWakeOnLanMacAddressAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readUserLabelLabelListCommandParams); + readUserLabelInteractionInfo.put( + "readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); + Map readUserLabelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUserLabelClusterRevisionCommandParams); + readUserLabelInteractionInfo.put( + "readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("userLabel", readUserLabelInteractionInfo); + Map readWakeOnLanInteractionInfo = new LinkedHashMap<>(); + Map readWakeOnLanWakeOnLanMacAddressCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readWakeOnLanMacAddressAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readWakeOnLanWakeOnLanMacAddressCommandParams - ); - readWakeOnLanInteractionInfo.put("readWakeOnLanMacAddressAttribute", readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo); - Map readWakeOnLanAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readAttributeListAttribute( - ( ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback - ) callback - ); - }, + readWakeOnLanWakeOnLanMacAddressCommandParams); + readWakeOnLanInteractionInfo.put( + "readWakeOnLanMacAddressAttribute", + readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo); + Map readWakeOnLanAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterAttributeListAttributeCallback(), - readWakeOnLanAttributeListCommandParams - ); - readWakeOnLanInteractionInfo.put("readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); - Map readWakeOnLanClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWakeOnLanClusterRevisionCommandParams - ); - readWakeOnLanInteractionInfo.put("readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("wakeOnLan", readWakeOnLanInteractionInfo); - Map readWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - Map readWiFiNetworkDiagnosticsBssidCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBssidAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readWakeOnLanAttributeListCommandParams); + readWakeOnLanInteractionInfo.put( + "readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); + Map readWakeOnLanClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWakeOnLanClusterRevisionCommandParams); + readWakeOnLanInteractionInfo.put( + "readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wakeOnLan", readWakeOnLanInteractionInfo); + Map readWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + Map readWiFiNetworkDiagnosticsBssidCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBssidAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readWiFiNetworkDiagnosticsBssidCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readSecurityTypeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsSecurityTypeCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readSecurityTypeAttribute", readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readWiFiVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsWiFiVersionCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readChannelNumberAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsChannelNumberCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readChannelNumberAttribute", readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsRssiCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readRssiAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsRssiCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconLostCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsBssidCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readSecurityTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsSecurityTypeCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readSecurityTypeAttribute", + readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readWiFiVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsWiFiVersionCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readChannelNumberAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsChannelNumberCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readChannelNumberAttribute", + readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsRssiCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readRssiAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsRssiCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBeaconLostCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconLostCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readBeaconLostCountAttribute", readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsBeaconLostCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readBeaconLostCountAttribute", + readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBeaconRxCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconRxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readBeaconRxCountAttribute", readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsBeaconRxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readBeaconRxCountAttribute", + readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); + Map + readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketMulticastRxCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketMulticastRxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastTxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketMulticastRxCountAttribute", + readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); + Map + readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketMulticastTxCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketMulticastTxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketMulticastTxCountAttribute", + readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketUnicastRxCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketUnicastRxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastTxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketUnicastRxCountAttribute", + readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketUnicastTxCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketUnicastTxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readCurrentMaxRateAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketUnicastTxCountAttribute", + readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readCurrentMaxRateAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readCurrentMaxRateAttribute", readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readCurrentMaxRateAttribute", + readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsOverrunCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readWiFiNetworkDiagnosticsAttributeListCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readAttributeListAttribute", readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsOverrunCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readOverrunCountAttribute", + readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readWiFiNetworkDiagnosticsAttributeListCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.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 - ); - readWiFiNetworkDiagnosticsInteractionInfo.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 - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo); - Map readWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map readWindowCoveringTypeCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTypeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTypeCommandParams - ); - readWindowCoveringInteractionInfo.put("readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionLiftAttribute", readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionTiltAttribute", readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); - Map readWindowCoveringConfigStatusCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readConfigStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringConfigStatusCommandParams - ); - readWindowCoveringInteractionInfo.put("readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercentageAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercentageAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercentageCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionLiftPercentageAttribute", readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercentageAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercentageAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercentageCommandParams - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readOperationalStatusAttribute", readWindowCoveringOperationalStatusAttributeInteractionInfo); - Map readWindowCoveringTargetPositionLiftPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionLiftPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.TargetPositionLiftPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTargetPositionLiftPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.put("readTargetPositionLiftPercent100thsAttribute", readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); - Map readWindowCoveringTargetPositionTiltPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionTiltPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.TargetPositionTiltPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTargetPositionTiltPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionLiftPercent100thsAttribute", readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); - Map readWindowCoveringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readAttributeListAttribute( - ( ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterAttributeListAttributeCallback(), - readWindowCoveringAttributeListCommandParams - ); - readWindowCoveringInteractionInfo.put("readAttributeListAttribute", readWindowCoveringAttributeListAttributeInteractionInfo); - Map readWindowCoveringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsFeatureMapCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.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); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo); + Map readWindowCoveringInteractionInfo = new LinkedHashMap<>(); + Map readWindowCoveringTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTypeCommandParams); + readWindowCoveringInteractionInfo.put( + "readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionLiftAttribute", + readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionTiltAttribute", + readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); + Map readWindowCoveringConfigStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readConfigStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringConfigStatusCommandParams); + readWindowCoveringInteractionInfo.put( + "readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftPercentageAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionLiftPercentageAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercentageCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionLiftPercentageAttribute", + readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltPercentageAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionTiltPercentageAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercentageCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readOperationalStatusAttribute", + readWindowCoveringOperationalStatusAttributeInteractionInfo); + Map + readWindowCoveringTargetPositionLiftPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTargetPositionLiftPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .TargetPositionLiftPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTargetPositionLiftPercent100thsCommandParams); + readWindowCoveringInteractionInfo.put( + "readTargetPositionLiftPercent100thsAttribute", + readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); + Map + readWindowCoveringTargetPositionTiltPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTargetPositionTiltPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .TargetPositionTiltPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTargetPositionTiltPercent100thsCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); + Map + readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionLiftPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercent100thsCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionLiftPercent100thsAttribute", + readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); + Map + readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionTiltPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercent100thsCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); + Map readWindowCoveringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterAttributeListAttributeCallback(), + readWindowCoveringAttributeListCommandParams); + readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("windowCovering", readWindowCoveringInteractionInfo); - return readAttributeMap; + readWindowCoveringFeatureMapCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("windowCovering", readWindowCoveringInteractionInfo); + return readAttributeMap; } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java index e701c60d01ca31..4ee787dfd94515 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java @@ -29,2292 +29,2466 @@ public class ClusterWriteMapping { public Map> getWriteAttributeMap() { Map> writeAttributeMap = new HashMap<>(); - Map writeAccessControlInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("accessControl", writeAccessControlInteractionInfo); - Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); - Map writeAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("administratorCommissioning", writeAdministratorCommissioningInteractionInfo); - Map writeApplicationBasicInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("applicationBasic", writeApplicationBasicInteractionInfo); - Map writeApplicationLauncherInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("applicationLauncher", writeApplicationLauncherInteractionInfo); - Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); - Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); - Map writeBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBasicNodeLabelCommandParams = new LinkedHashMap(); - CommandParameterInfo basicnodeLabelCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeBasicNodeLabelCommandParams.put("value",basicnodeLabelCommandParameterInfo); - InteractionInfo writeBasicNodeLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).writeNodeLabelAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicNodeLabelCommandParams - ); - writeBasicInteractionInfo.put("writeNodeLabelAttribute", writeBasicNodeLabelAttributeInteractionInfo); - Map writeBasicLocationCommandParams = new LinkedHashMap(); - CommandParameterInfo basiclocationCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeBasicLocationCommandParams.put("value",basiclocationCommandParameterInfo); - InteractionInfo writeBasicLocationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).writeLocationAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicLocationCommandParams - ); - writeBasicInteractionInfo.put("writeLocationAttribute", writeBasicLocationAttributeInteractionInfo); - Map writeBasicLocalConfigDisabledCommandParams = new LinkedHashMap(); - CommandParameterInfo basiclocalConfigDisabledCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeBasicLocalConfigDisabledCommandParams.put("value",basiclocalConfigDisabledCommandParameterInfo); - InteractionInfo writeBasicLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).writeLocalConfigDisabledAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicLocalConfigDisabledCommandParams - ); - writeBasicInteractionInfo.put("writeLocalConfigDisabledAttribute", writeBasicLocalConfigDisabledAttributeInteractionInfo); - writeAttributeMap.put("basic", writeBasicInteractionInfo); - Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); - CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); - Map writeBindingInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("binding", writeBindingInteractionInfo); - Map writeBooleanStateInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("booleanState", writeBooleanStateInteractionInfo); - Map writeBridgedActionsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("bridgedActions", writeBridgedActionsInteractionInfo); - Map writeBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("bridgedDeviceBasic", writeBridgedDeviceBasicInteractionInfo); - Map writeChannelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("channel", writeChannelInteractionInfo); - Map writeColorControlInteractionInfo = new LinkedHashMap<>(); - Map writeColorControlColorControlOptionsCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlcolorControlOptionsCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeColorControlColorControlOptionsCommandParams.put("value",colorControlcolorControlOptionsCommandParameterInfo); - InteractionInfo writeColorControlColorControlOptionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorControlOptionsAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorControlOptionsCommandParams - ); - writeColorControlInteractionInfo.put("writeColorControlOptionsAttribute", writeColorControlColorControlOptionsAttributeInteractionInfo); - Map writeColorControlWhitePointXCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlwhitePointXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlwhitePointYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); - Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map writeContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); - CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); - Map writeDescriptorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("descriptor", writeDescriptorInteractionInfo); - Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); - Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); - Map writeDoorLockLanguageCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocklanguageCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = new CommandParameterInfo("value", 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); - 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 writeDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); - Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); - Map writeEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); - Map writeFixedLabelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("fixedLabel", writeFixedLabelInteractionInfo); - Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); - Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); - CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); - Map writeGeneralDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); - Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("groupKeyManagement", writeGroupKeyManagementInteractionInfo); - Map writeGroupsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("groups", writeGroupsInteractionInfo); - Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); - Map writeIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); - CommandParameterInfo identifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("value", 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 writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); - Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); - Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); - Map writeLevelControlOptionsCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControloptionsCommandParameterInfo = new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo levelControlonLevelCommandParameterInfo = new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); - Map writeLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); - Map writeLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); - CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = new CommandParameterInfo("value", 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); - Map writeLowPowerInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("lowPower", writeLowPowerInteractionInfo); - Map writeMediaInputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("mediaInput", writeMediaInputInteractionInfo); - Map writeMediaPlaybackInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("mediaPlayback", writeMediaPlaybackInteractionInfo); - Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); - Map writeModeSelectOnModeCommandParams = new LinkedHashMap(); - CommandParameterInfo modeSelectonModeCommandParameterInfo = new CommandParameterInfo("value", 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 writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); - Map writeOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); - Map writeOtaSoftwareUpdateRequestorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); - Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); - Map writeOnOffInteractionInfo = new LinkedHashMap<>(); - Map writeOnOffOnTimeCommandParams = new LinkedHashMap(); - CommandParameterInfo onOffonTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); - Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); - Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); - Map writePowerSourceConfigurationInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); - Map writePressureMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); - Map writePumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); - Map writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); - CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = new CommandParameterInfo("value", 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); - Map writeRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); - Map writeScenesInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("scenes", writeScenesInteractionInfo); - Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); - Map writeSwitchInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("switch", writeSwitchInteractionInfo); - Map writeTargetNavigatorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("targetNavigator", writeTargetNavigatorInteractionInfo); - Map writeTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("temperatureMeasurement", writeTemperatureMeasurementInteractionInfo); - Map writeTestClusterInteractionInfo = new LinkedHashMap<>(); - Map writeTestClusterBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterBooleanCommandParams.put("value",testClusterbooleanCommandParameterInfo); - InteractionInfo writeTestClusterBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeBooleanAttribute", writeTestClusterBooleanAttributeInteractionInfo); - Map writeTestClusterBitmap8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterBitmap8CommandParams.put("value",testClusterbitmap8CommandParameterInfo); - InteractionInfo writeTestClusterBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap8CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap8Attribute", writeTestClusterBitmap8AttributeInteractionInfo); - Map writeTestClusterBitmap16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterBitmap16CommandParams.put("value",testClusterbitmap16CommandParameterInfo); - InteractionInfo writeTestClusterBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap16CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap16Attribute", writeTestClusterBitmap16AttributeInteractionInfo); - Map writeTestClusterBitmap32CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap32CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterBitmap32CommandParams.put("value",testClusterbitmap32CommandParameterInfo); - InteractionInfo writeTestClusterBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap32Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap32CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap32Attribute", writeTestClusterBitmap32AttributeInteractionInfo); - Map writeTestClusterBitmap64CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap64CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterBitmap64CommandParams.put("value",testClusterbitmap64CommandParameterInfo); - InteractionInfo writeTestClusterBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap64Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap64CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap64Attribute", writeTestClusterBitmap64AttributeInteractionInfo); - Map writeTestClusterInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt8uCommandParams.put("value",testClusterint8uCommandParameterInfo); - InteractionInfo writeTestClusterInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt8uAttribute", writeTestClusterInt8uAttributeInteractionInfo); - Map writeTestClusterInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt16uCommandParams.put("value",testClusterint16uCommandParameterInfo); - InteractionInfo writeTestClusterInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt16uAttribute", writeTestClusterInt16uAttributeInteractionInfo); - Map writeTestClusterInt24uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint24uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt24uCommandParams.put("value",testClusterint24uCommandParameterInfo); - InteractionInfo writeTestClusterInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt24uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt24uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt24uAttribute", writeTestClusterInt24uAttributeInteractionInfo); - Map writeTestClusterInt32uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint32uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt32uCommandParams.put("value",testClusterint32uCommandParameterInfo); - InteractionInfo writeTestClusterInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt32uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt32uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt32uAttribute", writeTestClusterInt32uAttributeInteractionInfo); - Map writeTestClusterInt40uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint40uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt40uCommandParams.put("value",testClusterint40uCommandParameterInfo); - InteractionInfo writeTestClusterInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt40uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt40uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt40uAttribute", writeTestClusterInt40uAttributeInteractionInfo); - Map writeTestClusterInt48uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint48uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt48uCommandParams.put("value",testClusterint48uCommandParameterInfo); - InteractionInfo writeTestClusterInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt48uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt48uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt48uAttribute", writeTestClusterInt48uAttributeInteractionInfo); - Map writeTestClusterInt56uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint56uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt56uCommandParams.put("value",testClusterint56uCommandParameterInfo); - InteractionInfo writeTestClusterInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt56uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt56uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt56uAttribute", writeTestClusterInt56uAttributeInteractionInfo); - Map writeTestClusterInt64uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint64uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt64uCommandParams.put("value",testClusterint64uCommandParameterInfo); - InteractionInfo writeTestClusterInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt64uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt64uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt64uAttribute", writeTestClusterInt64uAttributeInteractionInfo); - Map writeTestClusterInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt8sCommandParams.put("value",testClusterint8sCommandParameterInfo); - InteractionInfo writeTestClusterInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt8sAttribute", writeTestClusterInt8sAttributeInteractionInfo); - Map writeTestClusterInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt16sCommandParams.put("value",testClusterint16sCommandParameterInfo); - InteractionInfo writeTestClusterInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt16sAttribute", writeTestClusterInt16sAttributeInteractionInfo); - Map writeTestClusterInt24sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint24sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt24sCommandParams.put("value",testClusterint24sCommandParameterInfo); - InteractionInfo writeTestClusterInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt24sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt24sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt24sAttribute", writeTestClusterInt24sAttributeInteractionInfo); - Map writeTestClusterInt32sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint32sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt32sCommandParams.put("value",testClusterint32sCommandParameterInfo); - InteractionInfo writeTestClusterInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt32sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt32sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt32sAttribute", writeTestClusterInt32sAttributeInteractionInfo); - Map writeTestClusterInt40sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint40sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt40sCommandParams.put("value",testClusterint40sCommandParameterInfo); - InteractionInfo writeTestClusterInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt40sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt40sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt40sAttribute", writeTestClusterInt40sAttributeInteractionInfo); - Map writeTestClusterInt48sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint48sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt48sCommandParams.put("value",testClusterint48sCommandParameterInfo); - InteractionInfo writeTestClusterInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt48sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt48sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt48sAttribute", writeTestClusterInt48sAttributeInteractionInfo); - Map writeTestClusterInt56sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint56sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt56sCommandParams.put("value",testClusterint56sCommandParameterInfo); - InteractionInfo writeTestClusterInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt56sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt56sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt56sAttribute", writeTestClusterInt56sAttributeInteractionInfo); - Map writeTestClusterInt64sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint64sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt64sCommandParams.put("value",testClusterint64sCommandParameterInfo); - InteractionInfo writeTestClusterInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt64sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt64sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt64sAttribute", writeTestClusterInt64sAttributeInteractionInfo); - Map writeTestClusterEnum8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterenum8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterEnum8CommandParams.put("value",testClusterenum8CommandParameterInfo); - InteractionInfo writeTestClusterEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEnum8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnum8CommandParams - ); - writeTestClusterInteractionInfo.put("writeEnum8Attribute", writeTestClusterEnum8AttributeInteractionInfo); - Map writeTestClusterEnum16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterenum16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterEnum16CommandParams.put("value",testClusterenum16CommandParameterInfo); - InteractionInfo writeTestClusterEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEnum16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnum16CommandParams - ); - writeTestClusterInteractionInfo.put("writeEnum16Attribute", writeTestClusterEnum16AttributeInteractionInfo); - Map writeTestClusterFloatSingleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterfloatSingleCommandParameterInfo = new CommandParameterInfo("value", Float.class); - writeTestClusterFloatSingleCommandParams.put("value",testClusterfloatSingleCommandParameterInfo); - InteractionInfo writeTestClusterFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeFloatSingleAttribute( - (DefaultClusterCallback) callback, - (Float) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterFloatSingleCommandParams - ); - writeTestClusterInteractionInfo.put("writeFloatSingleAttribute", writeTestClusterFloatSingleAttributeInteractionInfo); - Map writeTestClusterFloatDoubleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterfloatDoubleCommandParameterInfo = new CommandParameterInfo("value", Double.class); - writeTestClusterFloatDoubleCommandParams.put("value",testClusterfloatDoubleCommandParameterInfo); - InteractionInfo writeTestClusterFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeFloatDoubleAttribute( - (DefaultClusterCallback) callback, - (Double) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterFloatDoubleCommandParams - ); - writeTestClusterInteractionInfo.put("writeFloatDoubleAttribute", writeTestClusterFloatDoubleAttributeInteractionInfo); - Map writeTestClusterOctetStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusteroctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); - writeTestClusterOctetStringCommandParams.put("value",testClusteroctetStringCommandParameterInfo); - InteractionInfo writeTestClusterOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterOctetStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeOctetStringAttribute", writeTestClusterOctetStringAttributeInteractionInfo); - Map writeTestClusterLongOctetStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterlongOctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); - writeTestClusterLongOctetStringCommandParams.put("value",testClusterlongOctetStringCommandParameterInfo); - InteractionInfo writeTestClusterLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeLongOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterLongOctetStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeLongOctetStringAttribute", writeTestClusterLongOctetStringAttributeInteractionInfo); - Map writeTestClusterCharStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustercharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeTestClusterCharStringCommandParams.put("value",testClustercharStringCommandParameterInfo); - InteractionInfo writeTestClusterCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeCharStringAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterCharStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeCharStringAttribute", writeTestClusterCharStringAttributeInteractionInfo); - Map writeTestClusterLongCharStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterlongCharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeTestClusterLongCharStringCommandParams.put("value",testClusterlongCharStringCommandParameterInfo); - InteractionInfo writeTestClusterLongCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeLongCharStringAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterLongCharStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeLongCharStringAttribute", writeTestClusterLongCharStringAttributeInteractionInfo); - Map writeTestClusterEpochUsCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterepochUsCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterEpochUsCommandParams.put("value",testClusterepochUsCommandParameterInfo); - InteractionInfo writeTestClusterEpochUsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEpochUsAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEpochUsCommandParams - ); - writeTestClusterInteractionInfo.put("writeEpochUsAttribute", writeTestClusterEpochUsAttributeInteractionInfo); - Map writeTestClusterEpochSCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterepochSCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterEpochSCommandParams.put("value",testClusterepochSCommandParameterInfo); - InteractionInfo writeTestClusterEpochSAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEpochSAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEpochSCommandParams - ); - writeTestClusterInteractionInfo.put("writeEpochSAttribute", writeTestClusterEpochSAttributeInteractionInfo); - Map writeTestClusterVendorIdCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustervendorIdCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterVendorIdCommandParams.put("value",testClustervendorIdCommandParameterInfo); - InteractionInfo writeTestClusterVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeVendorIdAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterVendorIdCommandParams - ); - writeTestClusterInteractionInfo.put("writeVendorIdAttribute", writeTestClusterVendorIdAttributeInteractionInfo); - Map writeTestClusterEnumAttrCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterenumAttrCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterEnumAttrCommandParams.put("value",testClusterenumAttrCommandParameterInfo); - InteractionInfo writeTestClusterEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEnumAttrAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnumAttrCommandParams - ); - writeTestClusterInteractionInfo.put("writeEnumAttrAttribute", writeTestClusterEnumAttrAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt8uCommandParams.put("value",testClusterrangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt8uAttribute", writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt8sCommandParams.put("value",testClusterrangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt8sAttribute", writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt16uCommandParams.put("value",testClusterrangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt16uAttribute", writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt16sCommandParams.put("value",testClusterrangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt16sAttribute", writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo); - Map writeTestClusterTimedWriteBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertimedWriteBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterTimedWriteBooleanCommandParams.put("value",testClustertimedWriteBooleanCommandParameterInfo); - InteractionInfo writeTestClusterTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeTimedWriteBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - , 10000 - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterTimedWriteBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeTimedWriteBooleanAttribute", writeTestClusterTimedWriteBooleanAttributeInteractionInfo); - Map writeTestClusterGeneralErrorBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustergeneralErrorBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterGeneralErrorBooleanCommandParams.put("value",testClustergeneralErrorBooleanCommandParameterInfo); - InteractionInfo writeTestClusterGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeGeneralErrorBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterGeneralErrorBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeGeneralErrorBooleanAttribute", writeTestClusterGeneralErrorBooleanAttributeInteractionInfo); - Map writeTestClusterClusterErrorBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterclusterErrorBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterClusterErrorBooleanCommandParams.put("value",testClusterclusterErrorBooleanCommandParameterInfo); - InteractionInfo writeTestClusterClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeClusterErrorBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterClusterErrorBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeClusterErrorBooleanAttribute", writeTestClusterClusterErrorBooleanAttributeInteractionInfo); - Map writeTestClusterUnsupportedCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterunsupportedCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterUnsupportedCommandParams.put("value",testClusterunsupportedCommandParameterInfo); - InteractionInfo writeTestClusterUnsupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeUnsupportedAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterUnsupportedCommandParams - ); - writeTestClusterInteractionInfo.put("writeUnsupportedAttribute", writeTestClusterUnsupportedAttributeInteractionInfo); - Map writeTestClusterNullableBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterNullableBooleanCommandParams.put("value",testClusternullableBooleanCommandParameterInfo); - InteractionInfo writeTestClusterNullableBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBooleanAttribute", writeTestClusterNullableBooleanAttributeInteractionInfo); - Map writeTestClusterNullableBitmap8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableBitmap8CommandParams.put("value",testClusternullableBitmap8CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap8CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap8Attribute", writeTestClusterNullableBitmap8AttributeInteractionInfo); - Map writeTestClusterNullableBitmap16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableBitmap16CommandParams.put("value",testClusternullableBitmap16CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap16CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap16Attribute", writeTestClusterNullableBitmap16AttributeInteractionInfo); - Map writeTestClusterNullableBitmap32CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap32CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableBitmap32CommandParams.put("value",testClusternullableBitmap32CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap32Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap32CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap32Attribute", writeTestClusterNullableBitmap32AttributeInteractionInfo); - Map writeTestClusterNullableBitmap64CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap64CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableBitmap64CommandParams.put("value",testClusternullableBitmap64CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap64Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap64CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap64Attribute", writeTestClusterNullableBitmap64AttributeInteractionInfo); - Map writeTestClusterNullableInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt8uCommandParams.put("value",testClusternullableInt8uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt8uAttribute", writeTestClusterNullableInt8uAttributeInteractionInfo); - Map writeTestClusterNullableInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt16uCommandParams.put("value",testClusternullableInt16uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt16uAttribute", writeTestClusterNullableInt16uAttributeInteractionInfo); - Map writeTestClusterNullableInt24uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt24uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt24uCommandParams.put("value",testClusternullableInt24uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt24uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt24uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt24uAttribute", writeTestClusterNullableInt24uAttributeInteractionInfo); - Map writeTestClusterNullableInt32uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt32uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt32uCommandParams.put("value",testClusternullableInt32uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt32uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt32uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt32uAttribute", writeTestClusterNullableInt32uAttributeInteractionInfo); - Map writeTestClusterNullableInt40uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt40uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt40uCommandParams.put("value",testClusternullableInt40uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt40uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt40uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt40uAttribute", writeTestClusterNullableInt40uAttributeInteractionInfo); - Map writeTestClusterNullableInt48uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt48uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt48uCommandParams.put("value",testClusternullableInt48uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt48uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt48uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt48uAttribute", writeTestClusterNullableInt48uAttributeInteractionInfo); - Map writeTestClusterNullableInt56uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt56uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt56uCommandParams.put("value",testClusternullableInt56uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt56uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt56uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt56uAttribute", writeTestClusterNullableInt56uAttributeInteractionInfo); - Map writeTestClusterNullableInt64uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt64uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt64uCommandParams.put("value",testClusternullableInt64uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt64uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt64uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt64uAttribute", writeTestClusterNullableInt64uAttributeInteractionInfo); - Map writeTestClusterNullableInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt8sCommandParams.put("value",testClusternullableInt8sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt8sAttribute", writeTestClusterNullableInt8sAttributeInteractionInfo); - Map writeTestClusterNullableInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt16sCommandParams.put("value",testClusternullableInt16sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt16sAttribute", writeTestClusterNullableInt16sAttributeInteractionInfo); - Map writeTestClusterNullableInt24sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt24sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt24sCommandParams.put("value",testClusternullableInt24sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt24sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt24sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt24sAttribute", writeTestClusterNullableInt24sAttributeInteractionInfo); - Map writeTestClusterNullableInt32sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt32sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt32sCommandParams.put("value",testClusternullableInt32sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt32sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt32sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt32sAttribute", writeTestClusterNullableInt32sAttributeInteractionInfo); - Map writeTestClusterNullableInt40sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt40sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt40sCommandParams.put("value",testClusternullableInt40sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt40sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt40sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt40sAttribute", writeTestClusterNullableInt40sAttributeInteractionInfo); - Map writeTestClusterNullableInt48sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt48sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt48sCommandParams.put("value",testClusternullableInt48sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt48sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt48sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt48sAttribute", writeTestClusterNullableInt48sAttributeInteractionInfo); - Map writeTestClusterNullableInt56sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt56sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt56sCommandParams.put("value",testClusternullableInt56sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt56sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt56sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt56sAttribute", writeTestClusterNullableInt56sAttributeInteractionInfo); - Map writeTestClusterNullableInt64sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt64sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt64sCommandParams.put("value",testClusternullableInt64sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt64sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt64sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt64sAttribute", writeTestClusterNullableInt64sAttributeInteractionInfo); - Map writeTestClusterNullableEnum8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableEnum8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnum8CommandParams.put("value",testClusternullableEnum8CommandParameterInfo); - InteractionInfo writeTestClusterNullableEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableEnum8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnum8CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableEnum8Attribute", writeTestClusterNullableEnum8AttributeInteractionInfo); - Map writeTestClusterNullableEnum16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableEnum16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnum16CommandParams.put("value",testClusternullableEnum16CommandParameterInfo); - InteractionInfo writeTestClusterNullableEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableEnum16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnum16CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableEnum16Attribute", writeTestClusterNullableEnum16AttributeInteractionInfo); - Map writeTestClusterNullableFloatSingleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableFloatSingleCommandParameterInfo = new CommandParameterInfo("value", Float.class); - writeTestClusterNullableFloatSingleCommandParams.put("value",testClusternullableFloatSingleCommandParameterInfo); - InteractionInfo writeTestClusterNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableFloatSingleAttribute( - (DefaultClusterCallback) callback, - (Float) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableFloatSingleCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableFloatSingleAttribute", writeTestClusterNullableFloatSingleAttributeInteractionInfo); - Map writeTestClusterNullableFloatDoubleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableFloatDoubleCommandParameterInfo = new CommandParameterInfo("value", Double.class); - writeTestClusterNullableFloatDoubleCommandParams.put("value",testClusternullableFloatDoubleCommandParameterInfo); - InteractionInfo writeTestClusterNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableFloatDoubleAttribute( - (DefaultClusterCallback) callback, - (Double) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableFloatDoubleCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableFloatDoubleAttribute", writeTestClusterNullableFloatDoubleAttributeInteractionInfo); - Map writeTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableOctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); - writeTestClusterNullableOctetStringCommandParams.put("value",testClusternullableOctetStringCommandParameterInfo); - InteractionInfo writeTestClusterNullableOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableOctetStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableOctetStringAttribute", writeTestClusterNullableOctetStringAttributeInteractionInfo); - Map writeTestClusterNullableCharStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableCharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeTestClusterNullableCharStringCommandParams.put("value",testClusternullableCharStringCommandParameterInfo); - InteractionInfo writeTestClusterNullableCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableCharStringAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableCharStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableCharStringAttribute", writeTestClusterNullableCharStringAttributeInteractionInfo); - Map writeTestClusterNullableEnumAttrCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableEnumAttrCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnumAttrCommandParams.put("value",testClusternullableEnumAttrCommandParameterInfo); - InteractionInfo writeTestClusterNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableEnumAttrAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnumAttrCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableEnumAttrAttribute", writeTestClusterNullableEnumAttrAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt8uCommandParams.put("value",testClusternullableRangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt8uAttribute", writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt8sCommandParams.put("value",testClusternullableRangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt8sAttribute", writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt16uCommandParams.put("value",testClusternullableRangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt16uAttribute", writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt16sCommandParams.put("value",testClusternullableRangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt16sAttribute", writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); - writeAttributeMap.put("testCluster", writeTestClusterInteractionInfo); - Map writeThermostatInteractionInfo = new LinkedHashMap<>(); - Map writeThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = new CommandParameterInfo("value", 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 writeThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = new CommandParameterInfo("value", 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 writeThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatsystemModeCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); - Map writeThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); - Map writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = new CommandParameterInfo("value", 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); - 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); - Map writeThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); - Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); - CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); - Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); - CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); - Map writeUserLabelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("userLabel", writeUserLabelInteractionInfo); - Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); - Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); - Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map writeWindowCoveringModeCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringmodeCommandParameterInfo = new CommandParameterInfo("value", 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 writeAccessControlInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("accessControl", writeAccessControlInteractionInfo); + Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); + Map writeAdministratorCommissioningInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "administratorCommissioning", writeAdministratorCommissioningInteractionInfo); + Map writeApplicationBasicInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("applicationBasic", writeApplicationBasicInteractionInfo); + Map writeApplicationLauncherInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("applicationLauncher", writeApplicationLauncherInteractionInfo); + Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); + Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); + Map writeBasicInteractionInfo = new LinkedHashMap<>(); + Map writeBasicNodeLabelCommandParams = + new LinkedHashMap(); + CommandParameterInfo basicnodeLabelCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeBasicNodeLabelCommandParams.put("value", basicnodeLabelCommandParameterInfo); + InteractionInfo writeBasicNodeLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .writeNodeLabelAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicNodeLabelCommandParams); + writeBasicInteractionInfo.put( + "writeNodeLabelAttribute", writeBasicNodeLabelAttributeInteractionInfo); + Map writeBasicLocationCommandParams = + new LinkedHashMap(); + CommandParameterInfo basiclocationCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeBasicLocationCommandParams.put("value", basiclocationCommandParameterInfo); + InteractionInfo writeBasicLocationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .writeLocationAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicLocationCommandParams); + writeBasicInteractionInfo.put( + "writeLocationAttribute", writeBasicLocationAttributeInteractionInfo); + Map writeBasicLocalConfigDisabledCommandParams = + new LinkedHashMap(); + CommandParameterInfo basiclocalConfigDisabledCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeBasicLocalConfigDisabledCommandParams.put( + "value", basiclocalConfigDisabledCommandParameterInfo); + InteractionInfo writeBasicLocalConfigDisabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .writeLocalConfigDisabledAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicLocalConfigDisabledCommandParams); + writeBasicInteractionInfo.put( + "writeLocalConfigDisabledAttribute", writeBasicLocalConfigDisabledAttributeInteractionInfo); + writeAttributeMap.put("basic", writeBasicInteractionInfo); + Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); + Map writeBinaryInputBasicOutOfServiceCommandParams = + new LinkedHashMap(); + CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); + Map writeBindingInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("binding", writeBindingInteractionInfo); + Map writeBooleanStateInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("booleanState", writeBooleanStateInteractionInfo); + Map writeBridgedActionsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bridgedActions", writeBridgedActionsInteractionInfo); + Map writeBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bridgedDeviceBasic", writeBridgedDeviceBasicInteractionInfo); + Map writeChannelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("channel", writeChannelInteractionInfo); + Map writeColorControlInteractionInfo = new LinkedHashMap<>(); + Map writeColorControlColorControlOptionsCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlcolorControlOptionsCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeColorControlColorControlOptionsCommandParams.put( + "value", colorControlcolorControlOptionsCommandParameterInfo); + InteractionInfo writeColorControlColorControlOptionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorControlOptionsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorControlOptionsCommandParams); + writeColorControlInteractionInfo.put( + "writeColorControlOptionsAttribute", + writeColorControlColorControlOptionsAttributeInteractionInfo); + Map writeColorControlWhitePointXCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlwhitePointXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlwhitePointYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); + Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); + Map writeContentLauncherSupportedStreamingProtocolsCommandParams = + new LinkedHashMap(); + CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); + Map writeDescriptorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("descriptor", writeDescriptorInteractionInfo); + Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); + Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); + Map writeDoorLockLanguageCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocklanguageCommandParameterInfo = + new CommandParameterInfo("value", 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 writeDoorLockAutoRelockTimeCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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 writeDoorLockEnableOneTouchLockingCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = + new CommandParameterInfo("value", 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 writeDoorLockEnablePrivacyModeButtonCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = + new CommandParameterInfo("value", 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 writeDoorLockWrongCodeEntryLimitCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); + Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); + Map writeEthernetNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); + Map writeFixedLabelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("fixedLabel", writeFixedLabelInteractionInfo); + Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); + Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); + Map writeGeneralCommissioningBreadcrumbCommandParams = + new LinkedHashMap(); + CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); + Map writeGeneralDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); + Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("groupKeyManagement", writeGroupKeyManagementInteractionInfo); + Map writeGroupsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("groups", writeGroupsInteractionInfo); + Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); + Map writeIdentifyIdentifyTimeCommandParams = + new LinkedHashMap(); + CommandParameterInfo identifyidentifyTimeCommandParameterInfo = + new CommandParameterInfo("value", 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 writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); + Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); + Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); + Map writeLevelControlOptionsCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControloptionsCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo levelControlonLevelCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); + Map writeLocalizationConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map writeLocalizationConfigurationActiveLocaleCommandParams = + new LinkedHashMap(); + CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = + new CommandParameterInfo("value", 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); + Map writeLowPowerInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("lowPower", writeLowPowerInteractionInfo); + Map writeMediaInputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("mediaInput", writeMediaInputInteractionInfo); + Map writeMediaPlaybackInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("mediaPlayback", writeMediaPlaybackInteractionInfo); + Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); + Map writeModeSelectOnModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo modeSelectonModeCommandParameterInfo = + new CommandParameterInfo("value", 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 writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); + Map writeNetworkCommissioningInterfaceEnabledCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); + Map writeOtaSoftwareUpdateProviderInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); + Map writeOtaSoftwareUpdateRequestorInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); + Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); + Map writeOnOffInteractionInfo = new LinkedHashMap<>(); + Map writeOnOffOnTimeCommandParams = + new LinkedHashMap(); + CommandParameterInfo onOffonTimeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); + Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); + Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); + Map writePowerSourceConfigurationInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); + Map writePressureMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); + Map writePumpConfigurationAndControlInteractionInfo = + new LinkedHashMap<>(); + Map + writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = + new LinkedHashMap(); + CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = + new CommandParameterInfo("value", 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); + Map writeRelativeHumidityMeasurementInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); + Map writeScenesInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("scenes", writeScenesInteractionInfo); + Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); + Map writeSwitchInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("switch", writeSwitchInteractionInfo); + Map writeTargetNavigatorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("targetNavigator", writeTargetNavigatorInteractionInfo); + Map writeTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("temperatureMeasurement", writeTemperatureMeasurementInteractionInfo); + Map writeTestClusterInteractionInfo = new LinkedHashMap<>(); + Map writeTestClusterBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterBooleanCommandParams.put("value", testClusterbooleanCommandParameterInfo); + InteractionInfo writeTestClusterBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeBooleanAttribute", writeTestClusterBooleanAttributeInteractionInfo); + Map writeTestClusterBitmap8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterBitmap8CommandParams.put("value", testClusterbitmap8CommandParameterInfo); + InteractionInfo writeTestClusterBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap8CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap8Attribute", writeTestClusterBitmap8AttributeInteractionInfo); + Map writeTestClusterBitmap16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterBitmap16CommandParams.put("value", testClusterbitmap16CommandParameterInfo); + InteractionInfo writeTestClusterBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap16CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap16Attribute", writeTestClusterBitmap16AttributeInteractionInfo); + Map writeTestClusterBitmap32CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap32CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterBitmap32CommandParams.put("value", testClusterbitmap32CommandParameterInfo); + InteractionInfo writeTestClusterBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap32Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap32CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap32Attribute", writeTestClusterBitmap32AttributeInteractionInfo); + Map writeTestClusterBitmap64CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap64CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterBitmap64CommandParams.put("value", testClusterbitmap64CommandParameterInfo); + InteractionInfo writeTestClusterBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap64Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap64CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap64Attribute", writeTestClusterBitmap64AttributeInteractionInfo); + Map writeTestClusterInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt8uCommandParams.put("value", testClusterint8uCommandParameterInfo); + InteractionInfo writeTestClusterInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt8uAttribute", writeTestClusterInt8uAttributeInteractionInfo); + Map writeTestClusterInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt16uCommandParams.put("value", testClusterint16uCommandParameterInfo); + InteractionInfo writeTestClusterInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt16uAttribute", writeTestClusterInt16uAttributeInteractionInfo); + Map writeTestClusterInt24uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint24uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt24uCommandParams.put("value", testClusterint24uCommandParameterInfo); + InteractionInfo writeTestClusterInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt24uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt24uAttribute", writeTestClusterInt24uAttributeInteractionInfo); + Map writeTestClusterInt32uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint32uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt32uCommandParams.put("value", testClusterint32uCommandParameterInfo); + InteractionInfo writeTestClusterInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt32uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt32uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt32uAttribute", writeTestClusterInt32uAttributeInteractionInfo); + Map writeTestClusterInt40uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint40uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt40uCommandParams.put("value", testClusterint40uCommandParameterInfo); + InteractionInfo writeTestClusterInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt40uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt40uAttribute", writeTestClusterInt40uAttributeInteractionInfo); + Map writeTestClusterInt48uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint48uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt48uCommandParams.put("value", testClusterint48uCommandParameterInfo); + InteractionInfo writeTestClusterInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt48uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt48uAttribute", writeTestClusterInt48uAttributeInteractionInfo); + Map writeTestClusterInt56uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint56uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt56uCommandParams.put("value", testClusterint56uCommandParameterInfo); + InteractionInfo writeTestClusterInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt56uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt56uAttribute", writeTestClusterInt56uAttributeInteractionInfo); + Map writeTestClusterInt64uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint64uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt64uCommandParams.put("value", testClusterint64uCommandParameterInfo); + InteractionInfo writeTestClusterInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt64uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt64uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt64uAttribute", writeTestClusterInt64uAttributeInteractionInfo); + Map writeTestClusterInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt8sCommandParams.put("value", testClusterint8sCommandParameterInfo); + InteractionInfo writeTestClusterInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt8sAttribute", writeTestClusterInt8sAttributeInteractionInfo); + Map writeTestClusterInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt16sCommandParams.put("value", testClusterint16sCommandParameterInfo); + InteractionInfo writeTestClusterInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt16sAttribute", writeTestClusterInt16sAttributeInteractionInfo); + Map writeTestClusterInt24sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint24sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt24sCommandParams.put("value", testClusterint24sCommandParameterInfo); + InteractionInfo writeTestClusterInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt24sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt24sAttribute", writeTestClusterInt24sAttributeInteractionInfo); + Map writeTestClusterInt32sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint32sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt32sCommandParams.put("value", testClusterint32sCommandParameterInfo); + InteractionInfo writeTestClusterInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt32sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt32sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt32sAttribute", writeTestClusterInt32sAttributeInteractionInfo); + Map writeTestClusterInt40sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint40sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt40sCommandParams.put("value", testClusterint40sCommandParameterInfo); + InteractionInfo writeTestClusterInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt40sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt40sAttribute", writeTestClusterInt40sAttributeInteractionInfo); + Map writeTestClusterInt48sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint48sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt48sCommandParams.put("value", testClusterint48sCommandParameterInfo); + InteractionInfo writeTestClusterInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt48sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt48sAttribute", writeTestClusterInt48sAttributeInteractionInfo); + Map writeTestClusterInt56sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint56sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt56sCommandParams.put("value", testClusterint56sCommandParameterInfo); + InteractionInfo writeTestClusterInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt56sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt56sAttribute", writeTestClusterInt56sAttributeInteractionInfo); + Map writeTestClusterInt64sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint64sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt64sCommandParams.put("value", testClusterint64sCommandParameterInfo); + InteractionInfo writeTestClusterInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt64sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt64sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt64sAttribute", writeTestClusterInt64sAttributeInteractionInfo); + Map writeTestClusterEnum8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterenum8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterEnum8CommandParams.put("value", testClusterenum8CommandParameterInfo); + InteractionInfo writeTestClusterEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEnum8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnum8CommandParams); + writeTestClusterInteractionInfo.put( + "writeEnum8Attribute", writeTestClusterEnum8AttributeInteractionInfo); + Map writeTestClusterEnum16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterenum16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterEnum16CommandParams.put("value", testClusterenum16CommandParameterInfo); + InteractionInfo writeTestClusterEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEnum16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnum16CommandParams); + writeTestClusterInteractionInfo.put( + "writeEnum16Attribute", writeTestClusterEnum16AttributeInteractionInfo); + Map writeTestClusterFloatSingleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterfloatSingleCommandParameterInfo = + new CommandParameterInfo("value", Float.class); + writeTestClusterFloatSingleCommandParams.put( + "value", testClusterfloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeFloatSingleAttribute( + (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatSingleCommandParams); + writeTestClusterInteractionInfo.put( + "writeFloatSingleAttribute", writeTestClusterFloatSingleAttributeInteractionInfo); + Map writeTestClusterFloatDoubleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterfloatDoubleCommandParameterInfo = + new CommandParameterInfo("value", Double.class); + writeTestClusterFloatDoubleCommandParams.put( + "value", testClusterfloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeFloatDoubleAttribute( + (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatDoubleCommandParams); + writeTestClusterInteractionInfo.put( + "writeFloatDoubleAttribute", writeTestClusterFloatDoubleAttributeInteractionInfo); + Map writeTestClusterOctetStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusteroctetStringCommandParameterInfo = + new CommandParameterInfo("value", byte[].class); + writeTestClusterOctetStringCommandParams.put( + "value", testClusteroctetStringCommandParameterInfo); + InteractionInfo writeTestClusterOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterOctetStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeOctetStringAttribute", writeTestClusterOctetStringAttributeInteractionInfo); + Map writeTestClusterLongOctetStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterlongOctetStringCommandParameterInfo = + new CommandParameterInfo("value", byte[].class); + writeTestClusterLongOctetStringCommandParams.put( + "value", testClusterlongOctetStringCommandParameterInfo); + InteractionInfo writeTestClusterLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeLongOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterLongOctetStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeLongOctetStringAttribute", writeTestClusterLongOctetStringAttributeInteractionInfo); + Map writeTestClusterCharStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustercharStringCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeTestClusterCharStringCommandParams.put("value", testClustercharStringCommandParameterInfo); + InteractionInfo writeTestClusterCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterCharStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeCharStringAttribute", writeTestClusterCharStringAttributeInteractionInfo); + Map writeTestClusterLongCharStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterlongCharStringCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeTestClusterLongCharStringCommandParams.put( + "value", testClusterlongCharStringCommandParameterInfo); + InteractionInfo writeTestClusterLongCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeLongCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterLongCharStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeLongCharStringAttribute", writeTestClusterLongCharStringAttributeInteractionInfo); + Map writeTestClusterEpochUsCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterepochUsCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterEpochUsCommandParams.put("value", testClusterepochUsCommandParameterInfo); + InteractionInfo writeTestClusterEpochUsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEpochUsAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEpochUsCommandParams); + writeTestClusterInteractionInfo.put( + "writeEpochUsAttribute", writeTestClusterEpochUsAttributeInteractionInfo); + Map writeTestClusterEpochSCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterepochSCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterEpochSCommandParams.put("value", testClusterepochSCommandParameterInfo); + InteractionInfo writeTestClusterEpochSAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEpochSAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEpochSCommandParams); + writeTestClusterInteractionInfo.put( + "writeEpochSAttribute", writeTestClusterEpochSAttributeInteractionInfo); + Map writeTestClusterVendorIdCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustervendorIdCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterVendorIdCommandParams.put("value", testClustervendorIdCommandParameterInfo); + InteractionInfo writeTestClusterVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeVendorIdAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterVendorIdCommandParams); + writeTestClusterInteractionInfo.put( + "writeVendorIdAttribute", writeTestClusterVendorIdAttributeInteractionInfo); + Map writeTestClusterEnumAttrCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterenumAttrCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterEnumAttrCommandParams.put("value", testClusterenumAttrCommandParameterInfo); + InteractionInfo writeTestClusterEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEnumAttrAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnumAttrCommandParams); + writeTestClusterInteractionInfo.put( + "writeEnumAttrAttribute", writeTestClusterEnumAttrAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt8uCommandParams.put( + "value", testClusterrangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt8uAttribute", + writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt8sCommandParams.put( + "value", testClusterrangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt8sAttribute", + writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt16uCommandParams.put( + "value", testClusterrangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt16uAttribute", + writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt16sCommandParams.put( + "value", testClusterrangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt16sAttribute", + writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo); + Map writeTestClusterTimedWriteBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertimedWriteBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterTimedWriteBooleanCommandParams.put( + "value", testClustertimedWriteBooleanCommandParameterInfo); + InteractionInfo writeTestClusterTimedWriteBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeTimedWriteBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value"), + 10000); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterTimedWriteBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeTimedWriteBooleanAttribute", + writeTestClusterTimedWriteBooleanAttributeInteractionInfo); + Map writeTestClusterGeneralErrorBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustergeneralErrorBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterGeneralErrorBooleanCommandParams.put( + "value", testClustergeneralErrorBooleanCommandParameterInfo); + InteractionInfo writeTestClusterGeneralErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeGeneralErrorBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterGeneralErrorBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeGeneralErrorBooleanAttribute", + writeTestClusterGeneralErrorBooleanAttributeInteractionInfo); + Map writeTestClusterClusterErrorBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterclusterErrorBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterClusterErrorBooleanCommandParams.put( + "value", testClusterclusterErrorBooleanCommandParameterInfo); + InteractionInfo writeTestClusterClusterErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeClusterErrorBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterClusterErrorBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeClusterErrorBooleanAttribute", + writeTestClusterClusterErrorBooleanAttributeInteractionInfo); + Map writeTestClusterUnsupportedCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterunsupportedCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterUnsupportedCommandParams.put( + "value", testClusterunsupportedCommandParameterInfo); + InteractionInfo writeTestClusterUnsupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeUnsupportedAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterUnsupportedCommandParams); + writeTestClusterInteractionInfo.put( + "writeUnsupportedAttribute", writeTestClusterUnsupportedAttributeInteractionInfo); + Map writeTestClusterNullableBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterNullableBooleanCommandParams.put( + "value", testClusternullableBooleanCommandParameterInfo); + InteractionInfo writeTestClusterNullableBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBooleanAttribute", writeTestClusterNullableBooleanAttributeInteractionInfo); + Map writeTestClusterNullableBitmap8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableBitmap8CommandParams.put( + "value", testClusternullableBitmap8CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap8CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap8Attribute", writeTestClusterNullableBitmap8AttributeInteractionInfo); + Map writeTestClusterNullableBitmap16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableBitmap16CommandParams.put( + "value", testClusternullableBitmap16CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap16CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap16Attribute", writeTestClusterNullableBitmap16AttributeInteractionInfo); + Map writeTestClusterNullableBitmap32CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap32CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableBitmap32CommandParams.put( + "value", testClusternullableBitmap32CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap32Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap32CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap32Attribute", writeTestClusterNullableBitmap32AttributeInteractionInfo); + Map writeTestClusterNullableBitmap64CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap64CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableBitmap64CommandParams.put( + "value", testClusternullableBitmap64CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap64Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap64CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap64Attribute", writeTestClusterNullableBitmap64AttributeInteractionInfo); + Map writeTestClusterNullableInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt8uCommandParams.put( + "value", testClusternullableInt8uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt8uAttribute", writeTestClusterNullableInt8uAttributeInteractionInfo); + Map writeTestClusterNullableInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt16uCommandParams.put( + "value", testClusternullableInt16uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt16uAttribute", writeTestClusterNullableInt16uAttributeInteractionInfo); + Map writeTestClusterNullableInt24uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt24uCommandParams.put( + "value", testClusternullableInt24uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt24uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt24uAttribute", writeTestClusterNullableInt24uAttributeInteractionInfo); + Map writeTestClusterNullableInt32uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt32uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt32uCommandParams.put( + "value", testClusternullableInt32uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt32uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt32uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt32uAttribute", writeTestClusterNullableInt32uAttributeInteractionInfo); + Map writeTestClusterNullableInt40uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt40uCommandParams.put( + "value", testClusternullableInt40uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt40uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt40uAttribute", writeTestClusterNullableInt40uAttributeInteractionInfo); + Map writeTestClusterNullableInt48uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt48uCommandParams.put( + "value", testClusternullableInt48uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt48uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt48uAttribute", writeTestClusterNullableInt48uAttributeInteractionInfo); + Map writeTestClusterNullableInt56uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt56uCommandParams.put( + "value", testClusternullableInt56uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt56uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt56uAttribute", writeTestClusterNullableInt56uAttributeInteractionInfo); + Map writeTestClusterNullableInt64uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt64uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt64uCommandParams.put( + "value", testClusternullableInt64uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt64uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt64uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt64uAttribute", writeTestClusterNullableInt64uAttributeInteractionInfo); + Map writeTestClusterNullableInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt8sCommandParams.put( + "value", testClusternullableInt8sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt8sAttribute", writeTestClusterNullableInt8sAttributeInteractionInfo); + Map writeTestClusterNullableInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt16sCommandParams.put( + "value", testClusternullableInt16sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt16sAttribute", writeTestClusterNullableInt16sAttributeInteractionInfo); + Map writeTestClusterNullableInt24sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt24sCommandParams.put( + "value", testClusternullableInt24sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt24sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt24sAttribute", writeTestClusterNullableInt24sAttributeInteractionInfo); + Map writeTestClusterNullableInt32sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt32sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt32sCommandParams.put( + "value", testClusternullableInt32sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt32sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt32sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt32sAttribute", writeTestClusterNullableInt32sAttributeInteractionInfo); + Map writeTestClusterNullableInt40sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt40sCommandParams.put( + "value", testClusternullableInt40sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt40sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt40sAttribute", writeTestClusterNullableInt40sAttributeInteractionInfo); + Map writeTestClusterNullableInt48sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt48sCommandParams.put( + "value", testClusternullableInt48sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt48sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt48sAttribute", writeTestClusterNullableInt48sAttributeInteractionInfo); + Map writeTestClusterNullableInt56sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt56sCommandParams.put( + "value", testClusternullableInt56sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt56sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt56sAttribute", writeTestClusterNullableInt56sAttributeInteractionInfo); + Map writeTestClusterNullableInt64sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt64sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt64sCommandParams.put( + "value", testClusternullableInt64sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt64sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt64sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt64sAttribute", writeTestClusterNullableInt64sAttributeInteractionInfo); + Map writeTestClusterNullableEnum8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableEnum8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnum8CommandParams.put( + "value", testClusternullableEnum8CommandParameterInfo); + InteractionInfo writeTestClusterNullableEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableEnum8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnum8CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableEnum8Attribute", writeTestClusterNullableEnum8AttributeInteractionInfo); + Map writeTestClusterNullableEnum16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableEnum16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnum16CommandParams.put( + "value", testClusternullableEnum16CommandParameterInfo); + InteractionInfo writeTestClusterNullableEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableEnum16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnum16CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableEnum16Attribute", writeTestClusterNullableEnum16AttributeInteractionInfo); + Map writeTestClusterNullableFloatSingleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatSingleCommandParameterInfo = + new CommandParameterInfo("value", Float.class); + writeTestClusterNullableFloatSingleCommandParams.put( + "value", testClusternullableFloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableFloatSingleAttribute( + (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatSingleCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableFloatSingleAttribute", + writeTestClusterNullableFloatSingleAttributeInteractionInfo); + Map writeTestClusterNullableFloatDoubleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatDoubleCommandParameterInfo = + new CommandParameterInfo("value", Double.class); + writeTestClusterNullableFloatDoubleCommandParams.put( + "value", testClusternullableFloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableFloatDoubleAttribute( + (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatDoubleCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableFloatDoubleAttribute", + writeTestClusterNullableFloatDoubleAttributeInteractionInfo); + Map writeTestClusterNullableOctetStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableOctetStringCommandParameterInfo = + new CommandParameterInfo("value", byte[].class); + writeTestClusterNullableOctetStringCommandParams.put( + "value", testClusternullableOctetStringCommandParameterInfo); + InteractionInfo writeTestClusterNullableOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableOctetStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableOctetStringAttribute", + writeTestClusterNullableOctetStringAttributeInteractionInfo); + Map writeTestClusterNullableCharStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableCharStringCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeTestClusterNullableCharStringCommandParams.put( + "value", testClusternullableCharStringCommandParameterInfo); + InteractionInfo writeTestClusterNullableCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableCharStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableCharStringAttribute", + writeTestClusterNullableCharStringAttributeInteractionInfo); + Map writeTestClusterNullableEnumAttrCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableEnumAttrCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnumAttrCommandParams.put( + "value", testClusternullableEnumAttrCommandParameterInfo); + InteractionInfo writeTestClusterNullableEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableEnumAttrAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnumAttrCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableEnumAttrAttribute", writeTestClusterNullableEnumAttrAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt8uCommandParams.put( + "value", testClusternullableRangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt8uAttribute", + writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt8sCommandParams.put( + "value", testClusternullableRangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt8sAttribute", + writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt16uCommandParams.put( + "value", testClusternullableRangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt16uAttribute", + writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt16sCommandParams.put( + "value", testClusternullableRangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt16sAttribute", + writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); + writeAttributeMap.put("testCluster", writeTestClusterInteractionInfo); + Map writeThermostatInteractionInfo = new LinkedHashMap<>(); + Map writeThermostatOccupiedCoolingSetpointCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = + new CommandParameterInfo("value", 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 writeThermostatMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = + new CommandParameterInfo("value", 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 writeThermostatControlSequenceOfOperationCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatsystemModeCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); + Map writeThermostatUserInterfaceConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map + writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo + thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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); + Map writeThreadNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); + Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); + Map writeTimeFormatLocalizationHourFormatCommandParams = + new LinkedHashMap(); + CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); + Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); + Map writeUnitLocalizationTemperatureUnitCommandParams = + new LinkedHashMap(); + CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); + Map writeUserLabelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("userLabel", writeUserLabelInteractionInfo); + Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); + Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); + Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); + Map writeWindowCoveringModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringmodeCommandParameterInfo = + new CommandParameterInfo("value", 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); return writeAttributeMap; } } From 59f8d022d8173e09632a5212ff682f643de4f1e1 Mon Sep 17 00:00:00 2001 From: Seth Rickard Date: Mon, 31 Jan 2022 22:04:51 +0000 Subject: [PATCH 11/14] fix ext flash size, default to board sector size --- examples/lock-app/cc13x2x7_26x2x7/chip.syscfg | 2 -- src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp | 4 ++-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/examples/lock-app/cc13x2x7_26x2x7/chip.syscfg b/examples/lock-app/cc13x2x7_26x2x7/chip.syscfg index 7ad5ad12df4fbb..b5153bf099c450 100644 --- a/examples/lock-app/cc13x2x7_26x2x7/chip.syscfg +++ b/examples/lock-app/cc13x2x7_26x2x7/chip.syscfg @@ -102,8 +102,6 @@ NVS1.internalFlash.regionSize = 0x4000; NVS2.$name = "CONFIG_NVSEXTERNAL"; NVS2.nvsType = "External"; // NVS Region Type NVS2.$hardware = system.deviceData.board.components.MX25R8035F; -NVS2.externalFlash.verifyBufferSize = 64; // Write Verification Buffer size (in bytes) -NVS2.externalFlash.regionSize = 0x256000; // Size of Region (in bytes) /* RF */ /* if an antenna component exists, assign it to the rf instance */ diff --git a/src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp b/src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp index 7de484f0d30d73..d05c949ea62fb7 100644 --- a/src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp +++ b/src/platform/cc13x2_26x2/OTAImageProcessorImpl.cpp @@ -87,8 +87,8 @@ CHIP_ERROR OTAImageProcessorImpl::ProcessBlock(ByteSpan & block) * have multiple images ready to be programmed into the internal flash of the * device. This design is only concerned with managing 1 image in external * flash starting at `IMG_START` and being defined by a meta header at address - * 0. Future designs may be able to take advantage of other images for - * rollback functionality. + * 0. Future designs may be able to take advantage of other images for rollback + * functionality, however this will require a larger external flash chip. */ #define IMG_START (4 * EFL_SIZE_META) From 4f5b8e1f1cee3985a169065a16a8f6c908925a84 Mon Sep 17 00:00:00 2001 From: Seth Rickard Date: Mon, 31 Jan 2022 22:19:29 +0000 Subject: [PATCH 12/14] Update lock diag clusters --- examples/lock-app/lock-common/lock-app.matter | 8 + examples/lock-app/lock-common/lock-app.zap | 28 +- .../chip/devicecontroller/ChipClusters.java | 23283 ++++++++-------- .../chip/devicecontroller/ChipStructs.java | 4075 +-- .../devicecontroller/ClusterInfoMapping.java | 16453 +++++------ .../devicecontroller/ClusterReadMapping.java | 16099 ++++++----- .../devicecontroller/ClusterWriteMapping.java | 4747 ++-- .../zap-generated/IMClusterCommandHandler.cpp | 160 + 8 files changed, 31112 insertions(+), 33741 deletions(-) diff --git a/examples/lock-app/lock-common/lock-app.matter b/examples/lock-app/lock-common/lock-app.matter index eea51823e44e5f..4f0f593c4360e3 100644 --- a/examples/lock-app/lock-common/lock-app.matter +++ b/examples/lock-app/lock-common/lock-app.matter @@ -147,6 +147,8 @@ server cluster EthernetNetworkDiagnostics = 55 { readonly attribute int64u timeSinceReset = 8; readonly global attribute bitmap32 featureMap = 65532; readonly global attribute int16u clusterRevision = 65533; + + command ResetCounts(): DefaultSuccess = 0; } server cluster FixedLabel = 64 { @@ -810,6 +812,8 @@ server cluster SoftwareDiagnostics = 52 { readonly attribute int64u currentHeapHighWatermark = 3; readonly global attribute bitmap32 featureMap = 65532; readonly global attribute int16u clusterRevision = 65533; + + command ResetWatermarks(): DefaultSuccess = 0; } server cluster ThreadNetworkDiagnostics = 53 { @@ -961,6 +965,8 @@ server cluster ThreadNetworkDiagnostics = 53 { readonly attribute NetworkFault activeNetworkFaultsList[] = 62; readonly global attribute bitmap32 featureMap = 65532; readonly global attribute int16u clusterRevision = 65533; + + command ResetCounts(): DefaultSuccess = 0; } server cluster TimeFormatLocalization = 44 { @@ -1054,6 +1060,8 @@ server cluster WiFiNetworkDiagnostics = 54 { readonly attribute int64u overrunCount = 12; readonly global attribute bitmap32 featureMap = 65532; readonly global attribute int16u clusterRevision = 65533; + + command ResetCounts(): DefaultSuccess = 0; } diff --git a/examples/lock-app/lock-common/lock-app.zap b/examples/lock-app/lock-common/lock-app.zap index e2af7e5ee15d1e..135a336e05e37c 100755 --- a/examples/lock-app/lock-common/lock-app.zap +++ b/examples/lock-app/lock-common/lock-app.zap @@ -2571,7 +2571,7 @@ "code": 0, "mfgCode": null, "source": "client", - "incoming": 0, + "incoming": 1, "outgoing": 1 } ], @@ -2701,7 +2701,16 @@ "define": "THREAD_NETWORK_DIAGNOSTICS_CLUSTER", "side": "client", "enabled": 0, - "commands": [], + "commands": [ + { + "name": "ResetCounts", + "code": 0, + "mfgCode": null, + "source": "client", + "incoming": 1, + "outgoing": 0 + } + ], "attributes": [ { "name": "ClusterRevision", @@ -3713,7 +3722,16 @@ "define": "WIFI_NETWORK_DIAGNOSTICS_CLUSTER", "side": "client", "enabled": 0, - "commands": [], + "commands": [ + { + "name": "ResetCounts", + "code": 0, + "mfgCode": null, + "source": "client", + "incoming": 1, + "outgoing": 0 + } + ], "attributes": [ { "name": "ClusterRevision", @@ -3981,7 +3999,7 @@ "code": 0, "mfgCode": null, "source": "client", - "incoming": 0, + "incoming": 1, "outgoing": 1 } ], @@ -6447,4 +6465,4 @@ "deviceIdentifier": 10 } ] -} \ No newline at end of file +} diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index 5d633d4dab05af..bad2cfd7e68797 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -21,6 +21,7 @@ import androidx.annotation.Nullable; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.Optional; @@ -28,69 +29,54 @@ public class ChipClusters { public interface DefaultClusterCallback { void onSuccess(); - void onError(Exception error); } public interface CharStringAttributeCallback { /** Indicates a successful read for a CHAR_STRING attribute. */ void onSuccess(String value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface OctetStringAttributeCallback { /** Indicates a successful read for an OCTET_STRING attribute. */ void onSuccess(byte[] value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface IntegerAttributeCallback { void onSuccess(int value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface LongAttributeCallback { void onSuccess(long value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface BooleanAttributeCallback { void onSuccess(boolean value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface FloatAttributeCallback { void onSuccess(float value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } public interface DoubleAttributeCallback { void onSuccess(double value); - void onError(Exception error); - default void onSubscriptionEstablished() {} } - public abstract static class BaseChipCluster { + public static abstract class BaseChipCluster { protected long chipClusterPtr; public BaseChipCluster(long devicePtr, int endpointId) { @@ -100,7 +86,7 @@ public BaseChipCluster(long devicePtr, int endpointId) { public abstract long initWithDevice(long devicePtr, int endpointId); public native void deleteCluster(long chipClusterPtr); - + @SuppressWarnings("deprecation") protected void finalize() throws Throwable { super.finalize(); @@ -122,129 +108,115 @@ public AccessControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AclAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ExtensionAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AclAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ExtensionAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAclAttribute(AclAttributeCallback callback) { + public void readAclAttribute( + AclAttributeCallback callback + ) { readAclAttribute(chipClusterPtr, callback); } - - public void writeAclAttribute( - DefaultClusterCallback callback, - ArrayList value) { + public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value) { writeAclAttribute(chipClusterPtr, callback, value, null); } - public void writeAclAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { + public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeAclAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeAclAttribute( - AclAttributeCallback callback, int minInterval, int maxInterval) { + AclAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAclAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readExtensionAttribute(ExtensionAttributeCallback callback) { + public void readExtensionAttribute( + ExtensionAttributeCallback callback + ) { readExtensionAttribute(chipClusterPtr, callback); } - - public void writeExtensionAttribute( - DefaultClusterCallback callback, - ArrayList value) { + public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value) { writeExtensionAttribute(chipClusterPtr, callback, value, null); } - public void writeExtensionAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { + public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeExtensionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeExtensionAttribute( - ExtensionAttributeCallback callback, int minInterval, int maxInterval) { + ExtensionAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeExtensionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAclAttribute(long chipClusterPtr, AclAttributeCallback callback); - - private native void writeAclAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeAclAttribute( - long chipClusterPtr, AclAttributeCallback callback, int minInterval, int maxInterval); - - private native void readExtensionAttribute( - long chipClusterPtr, ExtensionAttributeCallback callback); - - private native void writeExtensionAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeExtensionAttribute( - long chipClusterPtr, ExtensionAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readAclAttribute(long chipClusterPtr, + AclAttributeCallback callback + ); + + private native void writeAclAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeAclAttribute(long chipClusterPtr, + AclAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readExtensionAttribute(long chipClusterPtr, + ExtensionAttributeCallback callback + ); + + private native void writeExtensionAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeExtensionAttribute(long chipClusterPtr, + ExtensionAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class AccountLoginCluster extends BaseChipCluster { @@ -257,90 +229,85 @@ public AccountLoginCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void getSetupPINRequest( - GetSetupPINResponseCallback callback, - String tempAccountIdentifier, - int timedInvokeTimeoutMs) { + + public void getSetupPINRequest(GetSetupPINResponseCallback callback + , String tempAccountIdentifier + , int timedInvokeTimeoutMs) { getSetupPINRequest(chipClusterPtr, callback, tempAccountIdentifier, timedInvokeTimeoutMs); } - public void loginRequest( - DefaultClusterCallback callback, - String tempAccountIdentifier, - String setupPIN, - int timedInvokeTimeoutMs) { + + public void loginRequest(DefaultClusterCallback callback + , String tempAccountIdentifier, String setupPIN + , int timedInvokeTimeoutMs) { loginRequest(chipClusterPtr, callback, tempAccountIdentifier, setupPIN, timedInvokeTimeoutMs); } - public void logoutRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + public void logoutRequest(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { logoutRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - - private native void getSetupPINRequest( - long chipClusterPtr, - GetSetupPINResponseCallback Callback, - String tempAccountIdentifier, - @Nullable Integer timedInvokeTimeoutMs); - - private native void loginRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - String tempAccountIdentifier, - String setupPIN, - @Nullable Integer timedInvokeTimeoutMs); - - private native void logoutRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - + private native void getSetupPINRequest(long chipClusterPtr, GetSetupPINResponseCallback Callback + , String tempAccountIdentifier + , @Nullable Integer timedInvokeTimeoutMs); + private native void loginRequest(long chipClusterPtr, DefaultClusterCallback Callback + , String tempAccountIdentifier, String setupPIN + , @Nullable Integer timedInvokeTimeoutMs); + private native void logoutRequest(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); public interface GetSetupPINResponseCallback { void onSuccess(String setupPIN); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 AdministratorCommissioningCluster extends BaseChipCluster { @@ -353,156 +320,141 @@ public AdministratorCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void openBasicCommissioningWindow( - DefaultClusterCallback callback, Integer commissioningTimeout, int timedInvokeTimeoutMs) { - openBasicCommissioningWindow( - chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs); - } - - public void openCommissioningWindow( - DefaultClusterCallback callback, - Integer commissioningTimeout, - byte[] PAKEVerifier, - Integer discriminator, - Long iterations, - byte[] salt, - Integer passcodeID, - int timedInvokeTimeoutMs) { - openCommissioningWindow( - chipClusterPtr, - callback, - commissioningTimeout, - PAKEVerifier, - discriminator, - iterations, - salt, - passcodeID, - timedInvokeTimeoutMs); - } - - public void revokeCommissioning(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); + public void openBasicCommissioningWindow(DefaultClusterCallback callback + , Integer commissioningTimeout + , int timedInvokeTimeoutMs) { + openBasicCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs); } - private native void openBasicCommissioningWindow( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer commissioningTimeout, - @Nullable Integer timedInvokeTimeoutMs); - - private native void openCommissioningWindow( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer commissioningTimeout, - byte[] PAKEVerifier, - Integer discriminator, - Long iterations, - byte[] salt, - Integer passcodeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void revokeCommissioning( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AdminFabricIndexAttributeCallback { - void onSuccess(Integer value); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} + public void openCommissioningWindow(DefaultClusterCallback callback + , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID + , int timedInvokeTimeoutMs) { + openCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, PAKEVerifier, discriminator, iterations, salt, passcodeID, timedInvokeTimeoutMs); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void revokeCommissioning(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void openBasicCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback + , Integer commissioningTimeout + , @Nullable Integer timedInvokeTimeoutMs); + private native void openCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback + , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void revokeCommissioning(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface AdminFabricIndexAttributeCallback { + void onSuccess( Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readWindowStatusAttribute(IntegerAttributeCallback callback) { + public void readWindowStatusAttribute( + IntegerAttributeCallback callback + ) { readWindowStatusAttribute(chipClusterPtr, callback); } - public void subscribeWindowStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWindowStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAdminFabricIndexAttribute(AdminFabricIndexAttributeCallback callback) { + public void readAdminFabricIndexAttribute( + AdminFabricIndexAttributeCallback callback + ) { readAdminFabricIndexAttribute(chipClusterPtr, callback); } - public void subscribeAdminFabricIndexAttribute( - AdminFabricIndexAttributeCallback callback, int minInterval, int maxInterval) { + AdminFabricIndexAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAdminFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAdminVendorIdAttribute(IntegerAttributeCallback callback) { + public void readAdminVendorIdAttribute( + IntegerAttributeCallback callback + ) { readAdminVendorIdAttribute(chipClusterPtr, callback); } - public void subscribeAdminVendorIdAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAdminVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readWindowStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeWindowStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAdminFabricIndexAttribute( - long chipClusterPtr, AdminFabricIndexAttributeCallback callback); - - private native void subscribeAdminFabricIndexAttribute( - long chipClusterPtr, - AdminFabricIndexAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readAdminVendorIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAdminVendorIdAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readWindowStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeWindowStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAdminFabricIndexAttribute(long chipClusterPtr, + AdminFabricIndexAttributeCallback callback + ); + private native void subscribeAdminFabricIndexAttribute(long chipClusterPtr, + AdminFabricIndexAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readAdminVendorIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAdminVendorIdAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ApplicationBasicCluster extends BaseChipCluster { @@ -515,171 +467,187 @@ public ApplicationBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AllowedVendorListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AllowedVendorListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readVendorNameAttribute(CharStringAttributeCallback callback) { + public void readVendorNameAttribute( + CharStringAttributeCallback callback + ) { readVendorNameAttribute(chipClusterPtr, callback); } - public void subscribeVendorNameAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIdAttribute(IntegerAttributeCallback callback) { + public void readVendorIdAttribute( + IntegerAttributeCallback callback + ) { readVendorIdAttribute(chipClusterPtr, callback); } - public void subscribeVendorIdAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationNameAttribute(CharStringAttributeCallback callback) { + public void readApplicationNameAttribute( + CharStringAttributeCallback callback + ) { readApplicationNameAttribute(chipClusterPtr, callback); } - public void subscribeApplicationNameAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeApplicationNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductIdAttribute(IntegerAttributeCallback callback) { + public void readProductIdAttribute( + IntegerAttributeCallback callback + ) { readProductIdAttribute(chipClusterPtr, callback); } - public void subscribeProductIdAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeProductIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationStatusAttribute(IntegerAttributeCallback callback) { + public void readApplicationStatusAttribute( + IntegerAttributeCallback callback + ) { readApplicationStatusAttribute(chipClusterPtr, callback); } - public void subscribeApplicationStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeApplicationStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationVersionAttribute(CharStringAttributeCallback callback) { + public void readApplicationVersionAttribute( + CharStringAttributeCallback callback + ) { readApplicationVersionAttribute(chipClusterPtr, callback); } - public void subscribeApplicationVersionAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeApplicationVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAllowedVendorListAttribute(AllowedVendorListAttributeCallback callback) { + public void readAllowedVendorListAttribute( + AllowedVendorListAttributeCallback callback + ) { readAllowedVendorListAttribute(chipClusterPtr, callback); } - public void subscribeAllowedVendorListAttribute( - AllowedVendorListAttributeCallback callback, int minInterval, int maxInterval) { + AllowedVendorListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAllowedVendorListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readVendorNameAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeVendorNameAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readVendorIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeVendorIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readApplicationNameAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeApplicationNameAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readProductIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeProductIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readApplicationStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeApplicationStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readApplicationVersionAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeApplicationVersionAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readAllowedVendorListAttribute( - long chipClusterPtr, AllowedVendorListAttributeCallback callback); - - private native void subscribeAllowedVendorListAttribute( - long chipClusterPtr, - AllowedVendorListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeVendorIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApplicationNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeApplicationNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeProductIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApplicationStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeApplicationStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readApplicationVersionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeApplicationVersionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAllowedVendorListAttribute(long chipClusterPtr, + AllowedVendorListAttributeCallback callback + ); + private native void subscribeAllowedVendorListAttribute(long chipClusterPtr, + AllowedVendorListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ApplicationLauncherCluster extends BaseChipCluster { @@ -692,139 +660,121 @@ public ApplicationLauncherCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void hideAppRequest( - LauncherResponseCallback callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void hideAppRequest(LauncherResponseCallback callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { hideAppRequest(chipClusterPtr, callback, application, null); } - public void hideAppRequest( - LauncherResponseCallback callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - int timedInvokeTimeoutMs) { + public void hideAppRequest(LauncherResponseCallback callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , int timedInvokeTimeoutMs) { hideAppRequest(chipClusterPtr, callback, application, timedInvokeTimeoutMs); } - public void launchAppRequest( - LauncherResponseCallback callback, - String data, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void launchAppRequest(LauncherResponseCallback callback + , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { launchAppRequest(chipClusterPtr, callback, data, application, null); } - public void launchAppRequest( - LauncherResponseCallback callback, - String data, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - int timedInvokeTimeoutMs) { + public void launchAppRequest(LauncherResponseCallback callback + , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , int timedInvokeTimeoutMs) { launchAppRequest(chipClusterPtr, callback, data, application, timedInvokeTimeoutMs); } - public void stopAppRequest( - LauncherResponseCallback callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void stopAppRequest(LauncherResponseCallback callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { stopAppRequest(chipClusterPtr, callback, application, null); } - public void stopAppRequest( - LauncherResponseCallback callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - int timedInvokeTimeoutMs) { + public void stopAppRequest(LauncherResponseCallback callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , int timedInvokeTimeoutMs) { stopAppRequest(chipClusterPtr, callback, application, timedInvokeTimeoutMs); } - - private native void hideAppRequest( - long chipClusterPtr, - LauncherResponseCallback Callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - @Nullable Integer timedInvokeTimeoutMs); - - private native void launchAppRequest( - long chipClusterPtr, - LauncherResponseCallback Callback, - String data, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopAppRequest( - long chipClusterPtr, - LauncherResponseCallback Callback, - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - @Nullable Integer timedInvokeTimeoutMs); - + private native void hideAppRequest(long chipClusterPtr, LauncherResponseCallback Callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , @Nullable Integer timedInvokeTimeoutMs); + private native void launchAppRequest(long chipClusterPtr, LauncherResponseCallback Callback + , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopAppRequest(long chipClusterPtr, LauncherResponseCallback Callback + , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , @Nullable Integer timedInvokeTimeoutMs); public interface LauncherResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } - public interface ApplicationLauncherListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface ApplicationLauncherListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } public void readApplicationLauncherListAttribute( - ApplicationLauncherListAttributeCallback callback) { + ApplicationLauncherListAttributeCallback callback + ) { readApplicationLauncherListAttribute(chipClusterPtr, callback); } - public void subscribeApplicationLauncherListAttribute( - ApplicationLauncherListAttributeCallback callback, int minInterval, int maxInterval) { + ApplicationLauncherListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeApplicationLauncherListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readApplicationLauncherListAttribute( - long chipClusterPtr, ApplicationLauncherListAttributeCallback callback); - - private native void subscribeApplicationLauncherListAttribute( - long chipClusterPtr, - ApplicationLauncherListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readApplicationLauncherListAttribute(long chipClusterPtr, + ApplicationLauncherListAttributeCallback callback + ); + private native void subscribeApplicationLauncherListAttribute(long chipClusterPtr, + ApplicationLauncherListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class AudioOutputCluster extends BaseChipCluster { @@ -837,118 +787,120 @@ public AudioOutputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void renameOutputRequest(DefaultClusterCallback callback, Integer index, String name) { + public void renameOutputRequest(DefaultClusterCallback callback + , Integer index, String name) { renameOutputRequest(chipClusterPtr, callback, index, name, null); } - public void renameOutputRequest( - DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) { + public void renameOutputRequest(DefaultClusterCallback callback + , Integer index, String name + , int timedInvokeTimeoutMs) { renameOutputRequest(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); } - public void selectOutputRequest(DefaultClusterCallback callback, Integer index) { + public void selectOutputRequest(DefaultClusterCallback callback + , Integer index) { selectOutputRequest(chipClusterPtr, callback, index, null); } - public void selectOutputRequest( - DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) { + public void selectOutputRequest(DefaultClusterCallback callback + , Integer index + , int timedInvokeTimeoutMs) { selectOutputRequest(chipClusterPtr, callback, index, timedInvokeTimeoutMs); } + private native void renameOutputRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index, String name + , @Nullable Integer timedInvokeTimeoutMs); + private native void selectOutputRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index + , @Nullable Integer timedInvokeTimeoutMs); + + public interface AudioOutputListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void renameOutputRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer index, - String name, - @Nullable Integer timedInvokeTimeoutMs); - - private native void selectOutputRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer index, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AudioOutputListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readAudioOutputListAttribute(AudioOutputListAttributeCallback callback) { + public void readAudioOutputListAttribute( + AudioOutputListAttributeCallback callback + ) { readAudioOutputListAttribute(chipClusterPtr, callback); } - public void subscribeAudioOutputListAttribute( - AudioOutputListAttributeCallback callback, int minInterval, int maxInterval) { + AudioOutputListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAudioOutputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentAudioOutputAttribute(IntegerAttributeCallback callback) { + public void readCurrentAudioOutputAttribute( + IntegerAttributeCallback callback + ) { readCurrentAudioOutputAttribute(chipClusterPtr, callback); } - public void subscribeCurrentAudioOutputAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentAudioOutputAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAudioOutputListAttribute( - long chipClusterPtr, AudioOutputListAttributeCallback callback); - - private native void subscribeAudioOutputListAttribute( - long chipClusterPtr, - AudioOutputListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentAudioOutputAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentAudioOutputAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readAudioOutputListAttribute(long chipClusterPtr, + AudioOutputListAttributeCallback callback + ); + private native void subscribeAudioOutputListAttribute(long chipClusterPtr, + AudioOutputListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentAudioOutputAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentAudioOutputAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BarrierControlCluster extends BaseChipCluster { @@ -961,135 +913,153 @@ public BarrierControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void barrierControlGoToPercent(DefaultClusterCallback callback, Integer percentOpen) { + public void barrierControlGoToPercent(DefaultClusterCallback callback + , Integer percentOpen) { barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, null); } - public void barrierControlGoToPercent( - DefaultClusterCallback callback, Integer percentOpen, int timedInvokeTimeoutMs) { + public void barrierControlGoToPercent(DefaultClusterCallback callback + , Integer percentOpen + , int timedInvokeTimeoutMs) { barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, timedInvokeTimeoutMs); } - public void barrierControlStop(DefaultClusterCallback callback) { + public void barrierControlStop(DefaultClusterCallback callback + ) { barrierControlStop(chipClusterPtr, callback, null); } - public void barrierControlStop(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void barrierControlStop(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { barrierControlStop(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void barrierControlGoToPercent(long chipClusterPtr, DefaultClusterCallback Callback + , Integer percentOpen + , @Nullable Integer timedInvokeTimeoutMs); + private native void barrierControlStop(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void barrierControlGoToPercent( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer percentOpen, - @Nullable Integer timedInvokeTimeoutMs); - - private native void barrierControlStop( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readBarrierMovingStateAttribute(IntegerAttributeCallback callback) { + public void readBarrierMovingStateAttribute( + IntegerAttributeCallback callback + ) { readBarrierMovingStateAttribute(chipClusterPtr, callback); } - public void subscribeBarrierMovingStateAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBarrierMovingStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierSafetyStatusAttribute(IntegerAttributeCallback callback) { + public void readBarrierSafetyStatusAttribute( + IntegerAttributeCallback callback + ) { readBarrierSafetyStatusAttribute(chipClusterPtr, callback); } - public void subscribeBarrierSafetyStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBarrierSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierCapabilitiesAttribute(IntegerAttributeCallback callback) { + public void readBarrierCapabilitiesAttribute( + IntegerAttributeCallback callback + ) { readBarrierCapabilitiesAttribute(chipClusterPtr, callback); } - public void subscribeBarrierCapabilitiesAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBarrierCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierPositionAttribute(IntegerAttributeCallback callback) { + public void readBarrierPositionAttribute( + IntegerAttributeCallback callback + ) { readBarrierPositionAttribute(chipClusterPtr, callback); } - public void subscribeBarrierPositionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBarrierPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBarrierMovingStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBarrierMovingStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBarrierSafetyStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBarrierSafetyStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBarrierCapabilitiesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBarrierCapabilitiesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBarrierPositionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBarrierPositionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readBarrierMovingStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierMovingStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBarrierPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBarrierPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BasicCluster extends BaseChipCluster { @@ -1102,420 +1072,442 @@ public BasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface VendorIDAttributeCallback { - void onSuccess(Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface VendorIDAttributeCallback { + void onSuccess( Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readInteractionModelVersionAttribute(IntegerAttributeCallback callback) { + public void readInteractionModelVersionAttribute( + IntegerAttributeCallback callback + ) { readInteractionModelVersionAttribute(chipClusterPtr, callback); } - public void subscribeInteractionModelVersionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInteractionModelVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorNameAttribute(CharStringAttributeCallback callback) { + public void readVendorNameAttribute( + CharStringAttributeCallback callback + ) { readVendorNameAttribute(chipClusterPtr, callback); } - public void subscribeVendorNameAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIDAttribute(VendorIDAttributeCallback callback) { + public void readVendorIDAttribute( + VendorIDAttributeCallback callback + ) { readVendorIDAttribute(chipClusterPtr, callback); } - public void subscribeVendorIDAttribute( - VendorIDAttributeCallback callback, int minInterval, int maxInterval) { + VendorIDAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductNameAttribute(CharStringAttributeCallback callback) { + public void readProductNameAttribute( + CharStringAttributeCallback callback + ) { readProductNameAttribute(chipClusterPtr, callback); } - public void subscribeProductNameAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeProductNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductIDAttribute(IntegerAttributeCallback callback) { + public void readProductIDAttribute( + IntegerAttributeCallback callback + ) { readProductIDAttribute(chipClusterPtr, callback); } - public void subscribeProductIDAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeProductIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNodeLabelAttribute(CharStringAttributeCallback callback) { + public void readNodeLabelAttribute( + CharStringAttributeCallback callback + ) { readNodeLabelAttribute(chipClusterPtr, callback); } - public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value) { writeNodeLabelAttribute(chipClusterPtr, callback, value, null); } - public void writeNodeLabelAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeNodeLabelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNodeLabelAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNodeLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocationAttribute(CharStringAttributeCallback callback) { + public void readLocationAttribute( + CharStringAttributeCallback callback + ) { readLocationAttribute(chipClusterPtr, callback); } - public void writeLocationAttribute(DefaultClusterCallback callback, String value) { writeLocationAttribute(chipClusterPtr, callback, value, null); } - public void writeLocationAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLocationAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLocationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLocationAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLocationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readHardwareVersionAttribute(IntegerAttributeCallback callback) { + public void readHardwareVersionAttribute( + IntegerAttributeCallback callback + ) { readHardwareVersionAttribute(chipClusterPtr, callback); } - public void subscribeHardwareVersionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeHardwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readHardwareVersionStringAttribute(CharStringAttributeCallback callback) { + public void readHardwareVersionStringAttribute( + CharStringAttributeCallback callback + ) { readHardwareVersionStringAttribute(chipClusterPtr, callback); } - public void subscribeHardwareVersionStringAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeHardwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoftwareVersionAttribute(LongAttributeCallback callback) { + public void readSoftwareVersionAttribute( + LongAttributeCallback callback + ) { readSoftwareVersionAttribute(chipClusterPtr, callback); } - public void subscribeSoftwareVersionAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSoftwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoftwareVersionStringAttribute(CharStringAttributeCallback callback) { + public void readSoftwareVersionStringAttribute( + CharStringAttributeCallback callback + ) { readSoftwareVersionStringAttribute(chipClusterPtr, callback); } - public void subscribeSoftwareVersionStringAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSoftwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readManufacturingDateAttribute(CharStringAttributeCallback callback) { + public void readManufacturingDateAttribute( + CharStringAttributeCallback callback + ) { readManufacturingDateAttribute(chipClusterPtr, callback); } - public void subscribeManufacturingDateAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeManufacturingDateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartNumberAttribute(CharStringAttributeCallback callback) { + public void readPartNumberAttribute( + CharStringAttributeCallback callback + ) { readPartNumberAttribute(chipClusterPtr, callback); } - public void subscribePartNumberAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePartNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductURLAttribute(CharStringAttributeCallback callback) { + public void readProductURLAttribute( + CharStringAttributeCallback callback + ) { readProductURLAttribute(chipClusterPtr, callback); } - public void subscribeProductURLAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeProductURLAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductLabelAttribute(CharStringAttributeCallback callback) { + public void readProductLabelAttribute( + CharStringAttributeCallback callback + ) { readProductLabelAttribute(chipClusterPtr, callback); } - public void subscribeProductLabelAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeProductLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSerialNumberAttribute(CharStringAttributeCallback callback) { + public void readSerialNumberAttribute( + CharStringAttributeCallback callback + ) { readSerialNumberAttribute(chipClusterPtr, callback); } - public void subscribeSerialNumberAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSerialNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocalConfigDisabledAttribute(BooleanAttributeCallback callback) { + public void readLocalConfigDisabledAttribute( + BooleanAttributeCallback callback + ) { readLocalConfigDisabledAttribute(chipClusterPtr, callback); } - public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value) { writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, null); } - public void writeLocalConfigDisabledAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLocalConfigDisabledAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLocalConfigDisabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readReachableAttribute(BooleanAttributeCallback callback) { + public void readReachableAttribute( + BooleanAttributeCallback callback + ) { readReachableAttribute(chipClusterPtr, callback); } - public void subscribeReachableAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeReachableAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUniqueIDAttribute(CharStringAttributeCallback callback) { + public void readUniqueIDAttribute( + CharStringAttributeCallback callback + ) { readUniqueIDAttribute(chipClusterPtr, callback); } - public void subscribeUniqueIDAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeUniqueIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readInteractionModelVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeInteractionModelVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readVendorNameAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeVendorNameAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readVendorIDAttribute( - long chipClusterPtr, VendorIDAttributeCallback callback); - - private native void subscribeVendorIDAttribute( - long chipClusterPtr, VendorIDAttributeCallback callback, int minInterval, int maxInterval); - - private native void readProductNameAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeProductNameAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readProductIDAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeProductIDAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNodeLabelAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeNodeLabelAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNodeLabelAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readLocationAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeLocationAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLocationAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readHardwareVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeHardwareVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readHardwareVersionStringAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeHardwareVersionStringAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSoftwareVersionAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeSoftwareVersionAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSoftwareVersionStringAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeSoftwareVersionStringAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readManufacturingDateAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeManufacturingDateAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readPartNumberAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribePartNumberAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readProductURLAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeProductURLAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readProductLabelAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeProductLabelAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSerialNumberAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeSerialNumberAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readLocalConfigDisabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeLocalConfigDisabledAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLocalConfigDisabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readReachableAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeReachableAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readUniqueIDAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeUniqueIDAttribute( - long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readInteractionModelVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInteractionModelVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeVendorNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorIDAttribute(long chipClusterPtr, + VendorIDAttributeCallback callback + ); + private native void subscribeVendorIDAttribute(long chipClusterPtr, + VendorIDAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readProductNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeProductIDAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNodeLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeNodeLabelAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNodeLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLocationAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeLocationAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLocationAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readHardwareVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeHardwareVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readHardwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeHardwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSoftwareVersionAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSoftwareVersionAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSoftwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeSoftwareVersionStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readManufacturingDateAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeManufacturingDateAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPartNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribePartNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductURLAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductURLAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readProductLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeProductLabelAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSerialNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeSerialNumberAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLocalConfigDisabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeLocalConfigDisabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLocalConfigDisabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readReachableAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeReachableAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUniqueIDAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeUniqueIDAttribute(long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BinaryInputBasicCluster extends BaseChipCluster { @@ -1528,121 +1520,124 @@ public BinaryInputBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readOutOfServiceAttribute(BooleanAttributeCallback callback) { + public void readOutOfServiceAttribute( + BooleanAttributeCallback callback + ) { readOutOfServiceAttribute(chipClusterPtr, callback); } - public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value) { writeOutOfServiceAttribute(chipClusterPtr, callback, value, null); } - public void writeOutOfServiceAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeOutOfServiceAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOutOfServiceAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOutOfServiceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPresentValueAttribute(BooleanAttributeCallback callback) { + public void readPresentValueAttribute( + BooleanAttributeCallback callback + ) { readPresentValueAttribute(chipClusterPtr, callback); } - public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value) { writePresentValueAttribute(chipClusterPtr, callback, value, null); } - public void writePresentValueAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writePresentValueAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribePresentValueAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePresentValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStatusFlagsAttribute(IntegerAttributeCallback callback) { + public void readStatusFlagsAttribute( + IntegerAttributeCallback callback + ) { readStatusFlagsAttribute(chipClusterPtr, callback); } - public void subscribeStatusFlagsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStatusFlagsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOutOfServiceAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeOutOfServiceAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOutOfServiceAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPresentValueAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writePresentValueAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribePresentValueAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStatusFlagsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeStatusFlagsAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readOutOfServiceAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeOutOfServiceAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOutOfServiceAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPresentValueAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writePresentValueAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribePresentValueAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStatusFlagsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStatusFlagsAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BindingCluster extends BaseChipCluster { @@ -1655,103 +1650,77 @@ public BindingCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void bind( - DefaultClusterCallback callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId) { + public void bind(DefaultClusterCallback callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId) { bind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, null); } - public void bind( - DefaultClusterCallback callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId, - int timedInvokeTimeoutMs) { + public void bind(DefaultClusterCallback callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId + , int timedInvokeTimeoutMs) { bind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); } - public void unbind( - DefaultClusterCallback callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId) { + public void unbind(DefaultClusterCallback callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId) { unbind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, null); } - public void unbind( - DefaultClusterCallback callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId, - int timedInvokeTimeoutMs) { - unbind( - chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); + public void unbind(DefaultClusterCallback callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId + , int timedInvokeTimeoutMs) { + unbind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); } + private native void bind(long chipClusterPtr, DefaultClusterCallback Callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId + , @Nullable Integer timedInvokeTimeoutMs); + private native void unbind(long chipClusterPtr, DefaultClusterCallback Callback + , Long nodeId, Integer groupId, Integer endpointId, Long clusterId + , @Nullable Integer timedInvokeTimeoutMs); - private native void bind( - long chipClusterPtr, - DefaultClusterCallback Callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void unbind( - long chipClusterPtr, - DefaultClusterCallback Callback, - Long nodeId, - Integer groupId, - Integer endpointId, - Long clusterId, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); + private native void readAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + ); + private native void subscribeAttributeListAttribute(long chipClusterPtr, + AttributeListAttributeCallback callback + , int minInterval, int maxInterval); - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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); + private native void readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BooleanStateCluster extends BaseChipCluster { @@ -1764,61 +1733,68 @@ public BooleanStateCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readStateValueAttribute(BooleanAttributeCallback callback) { + public void readStateValueAttribute( + BooleanAttributeCallback callback + ) { readStateValueAttribute(chipClusterPtr, callback); } - public void subscribeStateValueAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStateValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readStateValueAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeStateValueAttribute( - long chipClusterPtr, BooleanAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readStateValueAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeStateValueAttribute(long chipClusterPtr, + BooleanAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BridgedActionsCluster extends BaseChipCluster { @@ -1831,375 +1807,284 @@ public BridgedActionsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void disableAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void disableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { disableAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void disableAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void disableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { disableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void disableActionWithDuration( - DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { + public void disableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void disableActionWithDuration( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Long duration, - int timedInvokeTimeoutMs) { - disableActionWithDuration( - chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void disableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void enableAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void enableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { enableAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void enableAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void enableAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { enableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void enableActionWithDuration( - DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { + public void enableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void enableActionWithDuration( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Long duration, - int timedInvokeTimeoutMs) { - enableActionWithDuration( - chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void enableActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void instantAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void instantAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { instantAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void instantAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void instantAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { instantAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void instantActionWithTransition( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Integer transitionTime) { - instantActionWithTransition( - chipClusterPtr, callback, actionID, invokeID, transitionTime, null); + public void instantActionWithTransition(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Integer transitionTime) { + instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, null); } - public void instantActionWithTransition( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Integer transitionTime, - int timedInvokeTimeoutMs) { - instantActionWithTransition( - chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs); + public void instantActionWithTransition(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Integer transitionTime + , int timedInvokeTimeoutMs) { + instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs); } - public void pauseAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void pauseAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { pauseAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void pauseAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void pauseAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { pauseAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void pauseActionWithDuration( - DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { + public void pauseActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void pauseActionWithDuration( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Long duration, - int timedInvokeTimeoutMs) { - pauseActionWithDuration( - chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void pauseActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void resumeAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void resumeAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { resumeAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void resumeAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void resumeAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { resumeAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void startAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void startAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { startAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void startAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void startAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { startAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void startActionWithDuration( - DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { + public void startActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration) { startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void startActionWithDuration( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - Long duration, - int timedInvokeTimeoutMs) { - startActionWithDuration( - chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void startActionWithDuration(DefaultClusterCallback callback + , Integer actionID, Optional invokeID, Long duration + , int timedInvokeTimeoutMs) { + startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void stopAction( - DefaultClusterCallback callback, Integer actionID, Optional invokeID) { + public void stopAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID) { stopAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void stopAction( - DefaultClusterCallback callback, - Integer actionID, - Optional invokeID, - int timedInvokeTimeoutMs) { + public void stopAction(DefaultClusterCallback callback + , Integer actionID, Optional invokeID + , int timedInvokeTimeoutMs) { stopAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } + private native void disableAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void disableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + private native void enableAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void enableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + private native void instantAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void instantActionWithTransition(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Integer transitionTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void pauseAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void pauseActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + private native void resumeAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void startAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + private native void startActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID, Long duration + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopAction(long chipClusterPtr, DefaultClusterCallback Callback + , Integer actionID, Optional invokeID + , @Nullable Integer timedInvokeTimeoutMs); + + public interface ActionListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface EndpointListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void disableAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void disableActionWithDuration( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - Long duration, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enableAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enableActionWithDuration( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - Long duration, - @Nullable Integer timedInvokeTimeoutMs); - - private native void instantAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void instantActionWithTransition( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - Integer transitionTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void pauseAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void pauseActionWithDuration( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - Long duration, - @Nullable Integer timedInvokeTimeoutMs); - - private native void resumeAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void startAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void startActionWithDuration( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - Long duration, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopAction( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer actionID, - Optional invokeID, - @Nullable Integer timedInvokeTimeoutMs); - - public interface ActionListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface EndpointListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readActionListAttribute(ActionListAttributeCallback callback) { + public void readActionListAttribute( + ActionListAttributeCallback callback + ) { readActionListAttribute(chipClusterPtr, callback); } - public void subscribeActionListAttribute( - ActionListAttributeCallback callback, int minInterval, int maxInterval) { + ActionListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeActionListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEndpointListAttribute(EndpointListAttributeCallback callback) { + public void readEndpointListAttribute( + EndpointListAttributeCallback callback + ) { readEndpointListAttribute(chipClusterPtr, callback); } - public void subscribeEndpointListAttribute( - EndpointListAttributeCallback callback, int minInterval, int maxInterval) { + EndpointListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeEndpointListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSetupUrlAttribute(CharStringAttributeCallback callback) { + public void readSetupUrlAttribute( + CharStringAttributeCallback callback + ) { readSetupUrlAttribute(chipClusterPtr, callback); } - public void subscribeSetupUrlAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSetupUrlAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readActionListAttribute( - long chipClusterPtr, ActionListAttributeCallback callback); - - private native void subscribeActionListAttribute( - long chipClusterPtr, - ActionListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readEndpointListAttribute( - long chipClusterPtr, EndpointListAttributeCallback callback); - - private native void subscribeEndpointListAttribute( - long chipClusterPtr, - EndpointListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSetupUrlAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeSetupUrlAttribute( - long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readActionListAttribute(long chipClusterPtr, + ActionListAttributeCallback callback + ); + private native void subscribeActionListAttribute(long chipClusterPtr, + ActionListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEndpointListAttribute(long chipClusterPtr, + EndpointListAttributeCallback callback + ); + private native void subscribeEndpointListAttribute(long chipClusterPtr, + EndpointListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSetupUrlAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeSetupUrlAttribute(long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class BridgedDeviceBasicCluster extends BaseChipCluster { @@ -2212,46 +2097,49 @@ public BridgedDeviceBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 ChannelCluster extends BaseChipCluster { @@ -2264,129 +2152,121 @@ public ChannelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void changeChannelByNumberRequest( - DefaultClusterCallback callback, Integer majorNumber, Integer minorNumber) { + public void changeChannelByNumberRequest(DefaultClusterCallback callback + , Integer majorNumber, Integer minorNumber) { changeChannelByNumberRequest(chipClusterPtr, callback, majorNumber, minorNumber, null); } - public void changeChannelByNumberRequest( - DefaultClusterCallback callback, - Integer majorNumber, - Integer minorNumber, - int timedInvokeTimeoutMs) { - changeChannelByNumberRequest( - chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs); + public void changeChannelByNumberRequest(DefaultClusterCallback callback + , Integer majorNumber, Integer minorNumber + , int timedInvokeTimeoutMs) { + changeChannelByNumberRequest(chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs); } - public void changeChannelRequest(ChangeChannelResponseCallback callback, String match) { + public void changeChannelRequest(ChangeChannelResponseCallback callback + , String match) { changeChannelRequest(chipClusterPtr, callback, match, null); } - public void changeChannelRequest( - ChangeChannelResponseCallback callback, String match, int timedInvokeTimeoutMs) { + public void changeChannelRequest(ChangeChannelResponseCallback callback + , String match + , int timedInvokeTimeoutMs) { changeChannelRequest(chipClusterPtr, callback, match, timedInvokeTimeoutMs); } - public void skipChannelRequest(DefaultClusterCallback callback, Integer count) { + public void skipChannelRequest(DefaultClusterCallback callback + , Integer count) { skipChannelRequest(chipClusterPtr, callback, count, null); } - public void skipChannelRequest( - DefaultClusterCallback callback, Integer count, int timedInvokeTimeoutMs) { + public void skipChannelRequest(DefaultClusterCallback callback + , Integer count + , int timedInvokeTimeoutMs) { skipChannelRequest(chipClusterPtr, callback, count, timedInvokeTimeoutMs); } - - private native void changeChannelByNumberRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer majorNumber, - Integer minorNumber, - @Nullable Integer timedInvokeTimeoutMs); - - private native void changeChannelRequest( - long chipClusterPtr, - ChangeChannelResponseCallback Callback, - String match, - @Nullable Integer timedInvokeTimeoutMs); - - private native void skipChannelRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer count, - @Nullable Integer timedInvokeTimeoutMs); - + private native void changeChannelByNumberRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer majorNumber, Integer minorNumber + , @Nullable Integer timedInvokeTimeoutMs); + private native void changeChannelRequest(long chipClusterPtr, ChangeChannelResponseCallback Callback + , String match + , @Nullable Integer timedInvokeTimeoutMs); + private native void skipChannelRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer count + , @Nullable Integer timedInvokeTimeoutMs); public interface ChangeChannelResponseCallback { void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType); - + void onError(Exception error); } - public interface ChannelListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface ChannelListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readChannelListAttribute(ChannelListAttributeCallback callback) { + public void readChannelListAttribute( + ChannelListAttributeCallback callback + ) { readChannelListAttribute(chipClusterPtr, callback); } - public void subscribeChannelListAttribute( - ChannelListAttributeCallback callback, int minInterval, int maxInterval) { + ChannelListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeChannelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readChannelListAttribute( - long chipClusterPtr, ChannelListAttributeCallback callback); - - private native void subscribeChannelListAttribute( - long chipClusterPtr, - ChannelListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readChannelListAttribute(long chipClusterPtr, + ChannelListAttributeCallback callback + ); + private native void subscribeChannelListAttribute(long chipClusterPtr, + ChannelListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ColorControlCluster extends BaseChipCluster { @@ -2399,2032 +2279,1562 @@ public ColorControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void colorLoopSet( - DefaultClusterCallback callback, - Integer updateFlags, - Integer action, - Integer direction, - Integer time, - Integer startHue, - Integer optionsMask, - Integer optionsOverride) { - colorLoopSet( - chipClusterPtr, - callback, - updateFlags, - action, - direction, - time, - startHue, - optionsMask, - optionsOverride, - null); - } - - public void colorLoopSet( - DefaultClusterCallback callback, - Integer updateFlags, - Integer action, - Integer direction, - Integer time, - Integer startHue, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - colorLoopSet( - chipClusterPtr, - callback, - updateFlags, - action, - direction, - time, - startHue, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void enhancedMoveHue( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride) { + public void colorLoopSet(DefaultClusterCallback callback + , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride) { + colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, null); + } + + public void colorLoopSet(DefaultClusterCallback callback + , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedMoveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void enhancedMoveHue( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - enhancedMoveHue( - chipClusterPtr, - callback, - moveMode, - rate, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void enhancedMoveToHue( - DefaultClusterCallback callback, - Integer enhancedHue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - enhancedMoveToHue( - chipClusterPtr, - callback, - enhancedHue, - direction, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void enhancedMoveToHue( - DefaultClusterCallback callback, - Integer enhancedHue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - enhancedMoveToHue( - chipClusterPtr, - callback, - enhancedHue, - direction, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void enhancedMoveToHueAndSaturation( - DefaultClusterCallback callback, - Integer enhancedHue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - enhancedMoveToHueAndSaturation( - chipClusterPtr, - callback, - enhancedHue, - saturation, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void enhancedMoveToHueAndSaturation( - DefaultClusterCallback callback, - Integer enhancedHue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - enhancedMoveToHueAndSaturation( - chipClusterPtr, - callback, - enhancedHue, - saturation, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void enhancedStepHue( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - enhancedStepHue( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void enhancedStepHue( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - enhancedStepHue( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveColor( - DefaultClusterCallback callback, - Integer rateX, - Integer rateY, - Integer optionsMask, - Integer optionsOverride) { + public void enhancedMoveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedMoveToHue(DefaultClusterCallback callback + , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, null); + } + + public void enhancedMoveToHue(DefaultClusterCallback callback + , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback + , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback + , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void enhancedStepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); + } + + public void enhancedStepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveColor(DefaultClusterCallback callback + , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride) { moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, null); } - public void moveColor( - DefaultClusterCallback callback, - Integer rateX, - Integer rateY, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveColor( - chipClusterPtr, - callback, - rateX, - rateY, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveColorTemperature( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride) { - moveColorTemperature( - chipClusterPtr, - callback, - moveMode, - rate, - colorTemperatureMinimum, - colorTemperatureMaximum, - optionsMask, - optionsOverride, - null); - } - - public void moveColorTemperature( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveColorTemperature( - chipClusterPtr, - callback, - moveMode, - rate, - colorTemperatureMinimum, - colorTemperatureMaximum, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveHue( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride) { + public void moveColor(DefaultClusterCallback callback + , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveColorTemperature(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride) { + moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, null); + } + + public void moveColorTemperature(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void moveHue( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveHue( - chipClusterPtr, - callback, - moveMode, - rate, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveSaturation( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride) { + public void moveHue(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveSaturation(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void moveSaturation( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveSaturation( - chipClusterPtr, - callback, - moveMode, - rate, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveToColor( - DefaultClusterCallback callback, - Integer colorX, - Integer colorY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - moveToColor( - chipClusterPtr, - callback, - colorX, - colorY, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void moveToColor( - DefaultClusterCallback callback, - Integer colorX, - Integer colorY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveToColor( - chipClusterPtr, - callback, - colorX, - colorY, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveToColorTemperature( - DefaultClusterCallback callback, - Integer colorTemperature, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - moveToColorTemperature( - chipClusterPtr, - callback, - colorTemperature, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void moveToColorTemperature( - DefaultClusterCallback callback, - Integer colorTemperature, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveToColorTemperature( - chipClusterPtr, - callback, - colorTemperature, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveToHue( - DefaultClusterCallback callback, - Integer hue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - moveToHue( - chipClusterPtr, - callback, - hue, - direction, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void moveToHue( - DefaultClusterCallback callback, - Integer hue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveToHue( - chipClusterPtr, - callback, - hue, - direction, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveToHueAndSaturation( - DefaultClusterCallback callback, - Integer hue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - moveToHueAndSaturation( - chipClusterPtr, - callback, - hue, - saturation, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void moveToHueAndSaturation( - DefaultClusterCallback callback, - Integer hue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveToHueAndSaturation( - chipClusterPtr, - callback, - hue, - saturation, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void moveToSaturation( - DefaultClusterCallback callback, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - moveToSaturation( - chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToSaturation( - DefaultClusterCallback callback, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - moveToSaturation( - chipClusterPtr, - callback, - saturation, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void stepColor( - DefaultClusterCallback callback, - Integer stepX, - Integer stepY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - stepColor( - chipClusterPtr, - callback, - stepX, - stepY, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void stepColor( - DefaultClusterCallback callback, - Integer stepX, - Integer stepY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - stepColor( - chipClusterPtr, - callback, - stepX, - stepY, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void stepColorTemperature( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride) { - stepColorTemperature( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - colorTemperatureMinimum, - colorTemperatureMaximum, - optionsMask, - optionsOverride, - null); - } - - public void stepColorTemperature( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - stepColorTemperature( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - colorTemperatureMinimum, - colorTemperatureMaximum, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void stepHue( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - stepHue( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void stepHue( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - stepHue( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void stepSaturation( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride) { - stepSaturation( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - null); - } - - public void stepSaturation( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { - stepSaturation( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionsMask, - optionsOverride, - timedInvokeTimeoutMs); - } - - public void stopMoveStep( - DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride) { + public void moveSaturation(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToColor(DefaultClusterCallback callback + , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToColor(DefaultClusterCallback callback + , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToColorTemperature(DefaultClusterCallback callback + , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToColorTemperature(chipClusterPtr, callback, colorTemperature, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToColorTemperature(DefaultClusterCallback callback + , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToColorTemperature(chipClusterPtr, callback, colorTemperature, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToHue(DefaultClusterCallback callback + , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToHue(DefaultClusterCallback callback + , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToHueAndSaturation(DefaultClusterCallback callback + , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToHueAndSaturation(DefaultClusterCallback callback + , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void moveToSaturation(DefaultClusterCallback callback + , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToSaturation(DefaultClusterCallback callback + , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepColor(DefaultClusterCallback callback + , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, null); + } + + public void stepColor(DefaultClusterCallback callback + , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepColorTemperature(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride) { + stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, null); + } + + public void stepColorTemperature(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); + } + + public void stepHue(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stepSaturation(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { + stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); + } + + public void stepSaturation(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { + stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); + } + + public void stopMoveStep(DefaultClusterCallback callback + , Integer optionsMask, Integer optionsOverride) { stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, null); } - public void stopMoveStep( - DefaultClusterCallback callback, - Integer optionsMask, - Integer optionsOverride, - int timedInvokeTimeoutMs) { + public void stopMoveStep(DefaultClusterCallback callback + , Integer optionsMask, Integer optionsOverride + , int timedInvokeTimeoutMs) { stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, timedInvokeTimeoutMs); } + private native void colorLoopSet(long chipClusterPtr, DefaultClusterCallback Callback + , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedMoveHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedMoveToHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedMoveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void enhancedStepHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveColor(long chipClusterPtr, DefaultClusterCallback Callback + , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToColor(long chipClusterPtr, DefaultClusterCallback Callback + , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback + , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepColor(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepHue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepSaturation(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopMoveStep(long chipClusterPtr, DefaultClusterCallback Callback + , Integer optionsMask, Integer optionsOverride + , @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void colorLoopSet( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer updateFlags, - Integer action, - Integer direction, - Integer time, - Integer startHue, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enhancedMoveHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enhancedMoveToHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer enhancedHue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enhancedMoveToHueAndSaturation( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer enhancedHue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void enhancedStepHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveColor( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer rateX, - Integer rateY, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveColorTemperature( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveSaturation( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToColor( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer colorX, - Integer colorY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToColorTemperature( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer colorTemperature, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer hue, - Integer direction, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToHueAndSaturation( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer hue, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToSaturation( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer saturation, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stepColor( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepX, - Integer stepY, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stepColorTemperature( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer colorTemperatureMinimum, - Integer colorTemperatureMaximum, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stepHue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stepSaturation( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopMoveStep( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer optionsMask, - Integer optionsOverride, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readCurrentHueAttribute(IntegerAttributeCallback callback) { + public void readCurrentHueAttribute( + IntegerAttributeCallback callback + ) { readCurrentHueAttribute(chipClusterPtr, callback); } - public void subscribeCurrentHueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentSaturationAttribute(IntegerAttributeCallback callback) { + public void readCurrentSaturationAttribute( + IntegerAttributeCallback callback + ) { readCurrentSaturationAttribute(chipClusterPtr, callback); } - public void subscribeCurrentSaturationAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentSaturationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRemainingTimeAttribute(IntegerAttributeCallback callback) { + public void readRemainingTimeAttribute( + IntegerAttributeCallback callback + ) { readRemainingTimeAttribute(chipClusterPtr, callback); } - public void subscribeRemainingTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentXAttribute(IntegerAttributeCallback callback) { + public void readCurrentXAttribute( + IntegerAttributeCallback callback + ) { readCurrentXAttribute(chipClusterPtr, callback); } - public void subscribeCurrentXAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentYAttribute(IntegerAttributeCallback callback) { + public void readCurrentYAttribute( + IntegerAttributeCallback callback + ) { readCurrentYAttribute(chipClusterPtr, callback); } - public void subscribeCurrentYAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDriftCompensationAttribute(IntegerAttributeCallback callback) { + public void readDriftCompensationAttribute( + IntegerAttributeCallback callback + ) { readDriftCompensationAttribute(chipClusterPtr, callback); } - public void subscribeDriftCompensationAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDriftCompensationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCompensationTextAttribute(CharStringAttributeCallback callback) { + public void readCompensationTextAttribute( + CharStringAttributeCallback callback + ) { readCompensationTextAttribute(chipClusterPtr, callback); } - public void subscribeCompensationTextAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCompensationTextAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTemperatureAttribute(IntegerAttributeCallback callback) { + public void readColorTemperatureAttribute( + IntegerAttributeCallback callback + ) { readColorTemperatureAttribute(chipClusterPtr, callback); } - public void subscribeColorTemperatureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorModeAttribute(IntegerAttributeCallback callback) { + public void readColorModeAttribute( + IntegerAttributeCallback callback + ) { readColorModeAttribute(chipClusterPtr, callback); } - public void subscribeColorModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorControlOptionsAttribute(IntegerAttributeCallback callback) { + public void readColorControlOptionsAttribute( + IntegerAttributeCallback callback + ) { readColorControlOptionsAttribute(chipClusterPtr, callback); } - public void writeColorControlOptionsAttribute(DefaultClusterCallback callback, Integer value) { writeColorControlOptionsAttribute(chipClusterPtr, callback, value, null); } - public void writeColorControlOptionsAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorControlOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorControlOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorControlOptionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorControlOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfPrimariesAttribute(IntegerAttributeCallback callback) { + public void readNumberOfPrimariesAttribute( + IntegerAttributeCallback callback + ) { readNumberOfPrimariesAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfPrimariesAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNumberOfPrimariesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1XAttribute(IntegerAttributeCallback callback) { + public void readPrimary1XAttribute( + IntegerAttributeCallback callback + ) { readPrimary1XAttribute(chipClusterPtr, callback); } - public void subscribePrimary1XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary1XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1YAttribute(IntegerAttributeCallback callback) { + public void readPrimary1YAttribute( + IntegerAttributeCallback callback + ) { readPrimary1YAttribute(chipClusterPtr, callback); } - public void subscribePrimary1YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary1YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary1IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary1IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary1IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary1IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2XAttribute(IntegerAttributeCallback callback) { + public void readPrimary2XAttribute( + IntegerAttributeCallback callback + ) { readPrimary2XAttribute(chipClusterPtr, callback); } - public void subscribePrimary2XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary2XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2YAttribute(IntegerAttributeCallback callback) { + public void readPrimary2YAttribute( + IntegerAttributeCallback callback + ) { readPrimary2YAttribute(chipClusterPtr, callback); } - public void subscribePrimary2YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary2YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary2IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary2IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary2IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary2IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3XAttribute(IntegerAttributeCallback callback) { + public void readPrimary3XAttribute( + IntegerAttributeCallback callback + ) { readPrimary3XAttribute(chipClusterPtr, callback); } - public void subscribePrimary3XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary3XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3YAttribute(IntegerAttributeCallback callback) { + public void readPrimary3YAttribute( + IntegerAttributeCallback callback + ) { readPrimary3YAttribute(chipClusterPtr, callback); } - public void subscribePrimary3YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary3YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary3IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary3IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary3IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary3IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4XAttribute(IntegerAttributeCallback callback) { + public void readPrimary4XAttribute( + IntegerAttributeCallback callback + ) { readPrimary4XAttribute(chipClusterPtr, callback); } - public void subscribePrimary4XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary4XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4YAttribute(IntegerAttributeCallback callback) { + public void readPrimary4YAttribute( + IntegerAttributeCallback callback + ) { readPrimary4YAttribute(chipClusterPtr, callback); } - public void subscribePrimary4YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary4YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary4IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary4IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary4IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary4IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5XAttribute(IntegerAttributeCallback callback) { + public void readPrimary5XAttribute( + IntegerAttributeCallback callback + ) { readPrimary5XAttribute(chipClusterPtr, callback); } - public void subscribePrimary5XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary5XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5YAttribute(IntegerAttributeCallback callback) { + public void readPrimary5YAttribute( + IntegerAttributeCallback callback + ) { readPrimary5YAttribute(chipClusterPtr, callback); } - public void subscribePrimary5YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary5YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary5IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary5IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary5IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary5IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6XAttribute(IntegerAttributeCallback callback) { + public void readPrimary6XAttribute( + IntegerAttributeCallback callback + ) { readPrimary6XAttribute(chipClusterPtr, callback); } - public void subscribePrimary6XAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary6XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6YAttribute(IntegerAttributeCallback callback) { + public void readPrimary6YAttribute( + IntegerAttributeCallback callback + ) { readPrimary6YAttribute(chipClusterPtr, callback); } - public void subscribePrimary6YAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary6YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6IntensityAttribute(IntegerAttributeCallback callback) { + public void readPrimary6IntensityAttribute( + IntegerAttributeCallback callback + ) { readPrimary6IntensityAttribute(chipClusterPtr, callback); } - public void subscribePrimary6IntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePrimary6IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWhitePointXAttribute(IntegerAttributeCallback callback) { + public void readWhitePointXAttribute( + IntegerAttributeCallback callback + ) { readWhitePointXAttribute(chipClusterPtr, callback); } - public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value) { writeWhitePointXAttribute(chipClusterPtr, callback, value, null); } - public void writeWhitePointXAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWhitePointXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeWhitePointXAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWhitePointXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWhitePointYAttribute(IntegerAttributeCallback callback) { + public void readWhitePointYAttribute( + IntegerAttributeCallback callback + ) { readWhitePointYAttribute(chipClusterPtr, callback); } - public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value) { writeWhitePointYAttribute(chipClusterPtr, callback, value, null); } - public void writeWhitePointYAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWhitePointYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeWhitePointYAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWhitePointYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRXAttribute(IntegerAttributeCallback callback) { + public void readColorPointRXAttribute( + IntegerAttributeCallback callback + ) { readColorPointRXAttribute(chipClusterPtr, callback); } - public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRXAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointRXAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointRXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRYAttribute(IntegerAttributeCallback callback) { + public void readColorPointRYAttribute( + IntegerAttributeCallback callback + ) { readColorPointRYAttribute(chipClusterPtr, callback); } - public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRYAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointRYAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointRYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRIntensityAttribute(IntegerAttributeCallback callback) { + public void readColorPointRIntensityAttribute( + IntegerAttributeCallback callback + ) { readColorPointRIntensityAttribute(chipClusterPtr, callback); } - public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRIntensityAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointRIntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointRIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGXAttribute(IntegerAttributeCallback callback) { + public void readColorPointGXAttribute( + IntegerAttributeCallback callback + ) { readColorPointGXAttribute(chipClusterPtr, callback); } - public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGXAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointGXAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointGXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGYAttribute(IntegerAttributeCallback callback) { + public void readColorPointGYAttribute( + IntegerAttributeCallback callback + ) { readColorPointGYAttribute(chipClusterPtr, callback); } - public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGYAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointGYAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointGYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGIntensityAttribute(IntegerAttributeCallback callback) { + public void readColorPointGIntensityAttribute( + IntegerAttributeCallback callback + ) { readColorPointGIntensityAttribute(chipClusterPtr, callback); } - public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGIntensityAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointGIntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointGIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBXAttribute(IntegerAttributeCallback callback) { + public void readColorPointBXAttribute( + IntegerAttributeCallback callback + ) { readColorPointBXAttribute(chipClusterPtr, callback); } - public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBXAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointBXAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointBXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBYAttribute(IntegerAttributeCallback callback) { + public void readColorPointBYAttribute( + IntegerAttributeCallback callback + ) { readColorPointBYAttribute(chipClusterPtr, callback); } - public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBYAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointBYAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointBYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBIntensityAttribute(IntegerAttributeCallback callback) { + public void readColorPointBIntensityAttribute( + IntegerAttributeCallback callback + ) { readColorPointBIntensityAttribute(chipClusterPtr, callback); } - public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBIntensityAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeColorPointBIntensityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorPointBIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnhancedCurrentHueAttribute(IntegerAttributeCallback callback) { + public void readEnhancedCurrentHueAttribute( + IntegerAttributeCallback callback + ) { readEnhancedCurrentHueAttribute(chipClusterPtr, callback); } - public void subscribeEnhancedCurrentHueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnhancedCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnhancedColorModeAttribute(IntegerAttributeCallback callback) { + public void readEnhancedColorModeAttribute( + IntegerAttributeCallback callback + ) { readEnhancedColorModeAttribute(chipClusterPtr, callback); } - public void subscribeEnhancedColorModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnhancedColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopActiveAttribute(IntegerAttributeCallback callback) { + public void readColorLoopActiveAttribute( + IntegerAttributeCallback callback + ) { readColorLoopActiveAttribute(chipClusterPtr, callback); } - public void subscribeColorLoopActiveAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorLoopActiveAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopDirectionAttribute(IntegerAttributeCallback callback) { + public void readColorLoopDirectionAttribute( + IntegerAttributeCallback callback + ) { readColorLoopDirectionAttribute(chipClusterPtr, callback); } - public void subscribeColorLoopDirectionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorLoopDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopTimeAttribute(IntegerAttributeCallback callback) { + public void readColorLoopTimeAttribute( + IntegerAttributeCallback callback + ) { readColorLoopTimeAttribute(chipClusterPtr, callback); } - public void subscribeColorLoopTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorLoopTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopStartEnhancedHueAttribute(IntegerAttributeCallback callback) { + public void readColorLoopStartEnhancedHueAttribute( + IntegerAttributeCallback callback + ) { readColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback); } - public void subscribeColorLoopStartEnhancedHueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeColorLoopStartEnhancedHueAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopStoredEnhancedHueAttribute(IntegerAttributeCallback callback) { + public void readColorLoopStoredEnhancedHueAttribute( + IntegerAttributeCallback callback + ) { readColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback); } - public void subscribeColorLoopStoredEnhancedHueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeColorLoopStoredEnhancedHueAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorCapabilitiesAttribute(IntegerAttributeCallback callback) { + public void readColorCapabilitiesAttribute( + IntegerAttributeCallback callback + ) { readColorCapabilitiesAttribute(chipClusterPtr, callback); } - public void subscribeColorCapabilitiesAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTempPhysicalMinAttribute(IntegerAttributeCallback callback) { + public void readColorTempPhysicalMinAttribute( + IntegerAttributeCallback callback + ) { readColorTempPhysicalMinAttribute(chipClusterPtr, callback); } - public void subscribeColorTempPhysicalMinAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorTempPhysicalMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTempPhysicalMaxAttribute(IntegerAttributeCallback callback) { + public void readColorTempPhysicalMaxAttribute( + IntegerAttributeCallback callback + ) { readColorTempPhysicalMaxAttribute(chipClusterPtr, callback); } - public void subscribeColorTempPhysicalMaxAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeColorTempPhysicalMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCoupleColorTempToLevelMinMiredsAttribute(IntegerAttributeCallback callback) { + public void readCoupleColorTempToLevelMinMiredsAttribute( + IntegerAttributeCallback callback + ) { readCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback); } - public void subscribeCoupleColorTempToLevelMinMiredsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeCoupleColorTempToLevelMinMiredsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpColorTemperatureMiredsAttribute(IntegerAttributeCallback callback) { + public void readStartUpColorTemperatureMiredsAttribute( + IntegerAttributeCallback callback + ) { readStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback); } - - public void writeStartUpColorTemperatureMiredsAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpColorTemperatureMiredsAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeStartUpColorTemperatureMiredsAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeStartUpColorTemperatureMiredsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeStartUpColorTemperatureMiredsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentSaturationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentSaturationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDriftCompensationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDriftCompensationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCompensationTextAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeCompensationTextAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorControlOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorControlOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorControlOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfPrimariesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfPrimariesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary1XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary1XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary1YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary1YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary1IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary1IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary2XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary2XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary2YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary2YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary2IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary2IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary3XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary3XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary3YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary3YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary3IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary3IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary4XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary4XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary4YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary4YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary4IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary4IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary5XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary5XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary5YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary5YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary5IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary5IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary6XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary6XAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary6YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary6YAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPrimary6IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePrimary6IntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWhitePointXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeWhitePointXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeWhitePointXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWhitePointYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeWhitePointYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeWhitePointYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointRXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointRXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointRXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointRYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointRYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointRYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointRIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointRIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointRIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointGXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointGXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointGXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointGYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointGYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointGYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointGIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointGIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointGIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointBXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointBXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointBXAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointBYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointBYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointBYAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorPointBIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeColorPointBIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeColorPointBIntensityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnhancedCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEnhancedCurrentHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnhancedColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEnhancedColorModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopActiveAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopActiveAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopDirectionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopStartEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopStartEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorCapabilitiesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorTempPhysicalMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeColorTempPhysicalMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } - private native void readCurrentSaturationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public static class ContentLauncherCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1290L; - private native void subscribeCurrentSaturationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public ContentLauncherCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } - private native void readRemainingTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + @Override + public native long initWithDevice(long devicePtr, int endpointId); - private native void subscribeRemainingTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public void launchContentRequest(LaunchResponseCallback callback + , Boolean autoPlay, String data, ArrayList search) { + launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, null); + } - private native void readCurrentXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public void launchContentRequest(LaunchResponseCallback callback + , Boolean autoPlay, String data, ArrayList search + , int timedInvokeTimeoutMs) { + launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, timedInvokeTimeoutMs); + } - private native void subscribeCurrentXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public void launchURLRequest(LaunchResponseCallback callback + , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation) { + launchURLRequest(chipClusterPtr, callback, contentURL, displayString, brandingInformation, null); + } - private native void readCurrentYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public void launchURLRequest(LaunchResponseCallback callback + , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation + , int timedInvokeTimeoutMs) { + launchURLRequest(chipClusterPtr, callback, contentURL, displayString, brandingInformation, timedInvokeTimeoutMs); + } + private native void launchContentRequest(long chipClusterPtr, LaunchResponseCallback Callback + , Boolean autoPlay, String data, ArrayList search + , @Nullable Integer timedInvokeTimeoutMs); + private native void launchURLRequest(long chipClusterPtr, LaunchResponseCallback Callback + , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation + , @Nullable Integer timedInvokeTimeoutMs); + public interface LaunchResponseCallback { + void onSuccess(Integer status, String data); + + void onError(Exception error); + } - private native void subscribeCurrentYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - private native void readDriftCompensationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public interface AcceptHeaderListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void subscribeDriftCompensationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public void readAcceptHeaderListAttribute( + AcceptHeaderListAttributeCallback callback + ) { + readAcceptHeaderListAttribute(chipClusterPtr, callback); + } + public void subscribeAcceptHeaderListAttribute( + AcceptHeaderListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAcceptHeaderListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readCompensationTextAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); + public void readSupportedStreamingProtocolsAttribute( + LongAttributeCallback callback + ) { + readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback); + } + public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value) { + writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, null); + } - private native void subscribeCompensationTextAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); + public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeSupportedStreamingProtocolsAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readColorTemperatureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void subscribeColorTemperatureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int 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 readColorModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorControlOptionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorControlOptionsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorControlOptionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfPrimariesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfPrimariesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary1XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary1XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary1YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary1YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary1IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary1IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary2XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary2XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary2YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary2YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary2IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary2IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary3XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary3XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary3YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary3YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary3IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary3IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary4XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary4XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary4YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary4YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary4IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary4IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary5XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary5XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary5YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary5YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary5IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary5IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary6XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary6XAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary6YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary6YAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPrimary6IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePrimary6IntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readWhitePointXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeWhitePointXAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeWhitePointXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readWhitePointYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeWhitePointYAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeWhitePointYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointRXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointRXAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointRXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointRYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointRYAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointRYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointRIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointRIntensityAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointRIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointGXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointGXAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointGXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointGYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointGYAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointGYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointGIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointGIntensityAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointGIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointBXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointBXAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointBXAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointBYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointBYAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointBYAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorPointBIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeColorPointBIntensityAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeColorPointBIntensityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnhancedCurrentHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeEnhancedCurrentHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnhancedColorModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeEnhancedColorModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorLoopActiveAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorLoopActiveAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorLoopDirectionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorLoopDirectionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorLoopTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorLoopTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorLoopStartEnhancedHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorLoopStartEnhancedHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorLoopStoredEnhancedHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorLoopStoredEnhancedHueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorCapabilitiesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorCapabilitiesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorTempPhysicalMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorTempPhysicalMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readColorTempPhysicalMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeColorTempPhysicalMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCoupleColorTempToLevelMinMiredsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCoupleColorTempToLevelMinMiredsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStartUpColorTemperatureMiredsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeStartUpColorTemperatureMiredsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeStartUpColorTemperatureMiredsAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - } - - public static class ContentLauncherCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1290L; - - public ContentLauncherCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } - - @Override - public native long initWithDevice(long devicePtr, int endpointId); - - public void launchContentRequest( - LaunchResponseCallback callback, - Boolean autoPlay, - String data, - ArrayList search) { - launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, null); - } - - public void launchContentRequest( - LaunchResponseCallback callback, - Boolean autoPlay, - String data, - ArrayList search, - int timedInvokeTimeoutMs) { - launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, timedInvokeTimeoutMs); - } - - public void launchURLRequest( - LaunchResponseCallback callback, - String contentURL, - String displayString, - ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation) { - launchURLRequest( - chipClusterPtr, callback, contentURL, displayString, brandingInformation, null); - } - - public void launchURLRequest( - LaunchResponseCallback callback, - String contentURL, - String displayString, - ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation, - int timedInvokeTimeoutMs) { - launchURLRequest( - chipClusterPtr, - callback, - contentURL, - displayString, - brandingInformation, - timedInvokeTimeoutMs); - } - - private native void launchContentRequest( - long chipClusterPtr, - LaunchResponseCallback Callback, - Boolean autoPlay, - String data, - ArrayList search, - @Nullable Integer timedInvokeTimeoutMs); - - private native void launchURLRequest( - long chipClusterPtr, - LaunchResponseCallback Callback, - String contentURL, - String displayString, - ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation, - @Nullable Integer timedInvokeTimeoutMs); - - public interface LaunchResponseCallback { - void onSuccess(Integer status, String data); - - void onError(Exception error); - } - - public interface AcceptHeaderListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readAcceptHeaderListAttribute(AcceptHeaderListAttributeCallback callback) { - readAcceptHeaderListAttribute(chipClusterPtr, callback); - } - - public void subscribeAcceptHeaderListAttribute( - AcceptHeaderListAttributeCallback callback, int minInterval, int maxInterval) { - subscribeAcceptHeaderListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readSupportedStreamingProtocolsAttribute(LongAttributeCallback callback) { - readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback); - } - - public void writeSupportedStreamingProtocolsAttribute( - DefaultClusterCallback callback, Long value) { - writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, null); - } - - public void writeSupportedStreamingProtocolsAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { - writeSupportedStreamingProtocolsAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); - } - - public void subscribeSupportedStreamingProtocolsAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeSupportedStreamingProtocolsAttribute( - 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 readClusterRevisionAttribute(IntegerAttributeCallback callback) { - readClusterRevisionAttribute(chipClusterPtr, callback); - } - - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - private native void readAcceptHeaderListAttribute( - long chipClusterPtr, AcceptHeaderListAttributeCallback callback); - - private native void subscribeAcceptHeaderListAttribute( - long chipClusterPtr, - AcceptHeaderListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSupportedStreamingProtocolsAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void writeSupportedStreamingProtocolsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeSupportedStreamingProtocolsAttribute( - long chipClusterPtr, LongAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - } + private native void readAcceptHeaderListAttribute(long chipClusterPtr, + AcceptHeaderListAttributeCallback callback + ); + private native void subscribeAcceptHeaderListAttribute(long chipClusterPtr, + AcceptHeaderListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSupportedStreamingProtocolsAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeSupportedStreamingProtocolsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSupportedStreamingProtocolsAttribute(long chipClusterPtr, + LongAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } public static class DescriptorCluster extends BaseChipCluster { public static final long CLUSTER_ID = 29L; @@ -4436,147 +3846,145 @@ public DescriptorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface DeviceListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ServerListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ClientListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface PartsListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface DeviceListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ServerListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ClientListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface PartsListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readDeviceListAttribute(DeviceListAttributeCallback callback) { + public void readDeviceListAttribute( + DeviceListAttributeCallback callback + ) { readDeviceListAttribute(chipClusterPtr, callback); } - public void subscribeDeviceListAttribute( - DeviceListAttributeCallback callback, int minInterval, int maxInterval) { + DeviceListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeDeviceListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readServerListAttribute(ServerListAttributeCallback callback) { + public void readServerListAttribute( + ServerListAttributeCallback callback + ) { readServerListAttribute(chipClusterPtr, callback); } - public void subscribeServerListAttribute( - ServerListAttributeCallback callback, int minInterval, int maxInterval) { + ServerListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeServerListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClientListAttribute(ClientListAttributeCallback callback) { + public void readClientListAttribute( + ClientListAttributeCallback callback + ) { readClientListAttribute(chipClusterPtr, callback); } - public void subscribeClientListAttribute( - ClientListAttributeCallback callback, int minInterval, int maxInterval) { + ClientListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeClientListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartsListAttribute(PartsListAttributeCallback callback) { + public void readPartsListAttribute( + PartsListAttributeCallback callback + ) { readPartsListAttribute(chipClusterPtr, callback); } - public void subscribePartsListAttribute( - PartsListAttributeCallback callback, int minInterval, int maxInterval) { + PartsListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribePartsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readDeviceListAttribute( - long chipClusterPtr, DeviceListAttributeCallback callback); - - private native void subscribeDeviceListAttribute( - long chipClusterPtr, - DeviceListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readServerListAttribute( - long chipClusterPtr, ServerListAttributeCallback callback); - - private native void subscribeServerListAttribute( - long chipClusterPtr, - ServerListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readClientListAttribute( - long chipClusterPtr, ClientListAttributeCallback callback); - - private native void subscribeClientListAttribute( - long chipClusterPtr, - ClientListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readPartsListAttribute( - long chipClusterPtr, PartsListAttributeCallback callback); - - private native void subscribePartsListAttribute( - long chipClusterPtr, PartsListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readDeviceListAttribute(long chipClusterPtr, + DeviceListAttributeCallback callback + ); + private native void subscribeDeviceListAttribute(long chipClusterPtr, + DeviceListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readServerListAttribute(long chipClusterPtr, + ServerListAttributeCallback callback + ); + private native void subscribeServerListAttribute(long chipClusterPtr, + ServerListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readClientListAttribute(long chipClusterPtr, + ClientListAttributeCallback callback + ); + private native void subscribeClientListAttribute(long chipClusterPtr, + ClientListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPartsListAttribute(long chipClusterPtr, + PartsListAttributeCallback callback + ); + private native void subscribePartsListAttribute(long chipClusterPtr, + PartsListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class DiagnosticLogsCluster extends BaseChipCluster { @@ -4589,69 +3997,50 @@ public DiagnosticLogsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void retrieveLogsRequest( - RetrieveLogsResponseCallback callback, - Integer intent, - Integer requestedProtocol, - byte[] transferFileDesignator) { - retrieveLogsRequest( - chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null); - } - - public void retrieveLogsRequest( - RetrieveLogsResponseCallback callback, - Integer intent, - Integer requestedProtocol, - byte[] transferFileDesignator, - int timedInvokeTimeoutMs) { - retrieveLogsRequest( - chipClusterPtr, - callback, - intent, - requestedProtocol, - transferFileDesignator, - timedInvokeTimeoutMs); - } - - private native void retrieveLogsRequest( - long chipClusterPtr, - RetrieveLogsResponseCallback Callback, - Integer intent, - Integer requestedProtocol, - byte[] transferFileDesignator, - @Nullable Integer timedInvokeTimeoutMs); + public void retrieveLogsRequest(RetrieveLogsResponseCallback callback + , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator) { + retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null); + } + public void retrieveLogsRequest(RetrieveLogsResponseCallback callback + , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator + , int timedInvokeTimeoutMs) { + retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, timedInvokeTimeoutMs); + } + private native void retrieveLogsRequest(long chipClusterPtr, RetrieveLogsResponseCallback Callback + , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator + , @Nullable Integer timedInvokeTimeoutMs); public interface RetrieveLogsResponseCallback { void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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); } public static class DoorLockCluster extends BaseChipCluster { @@ -4664,886 +4053,733 @@ public DoorLockCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void clearCredential( - DefaultClusterCallback callback, - @Nullable ChipStructs.DoorLockClusterDlCredential credential, - int timedInvokeTimeoutMs) { + + public void clearCredential(DefaultClusterCallback callback + , @Nullable ChipStructs.DoorLockClusterDlCredential credential + , int timedInvokeTimeoutMs) { clearCredential(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); } - public void clearUser( - DefaultClusterCallback callback, Integer userIndex, int timedInvokeTimeoutMs) { + + public void clearUser(DefaultClusterCallback callback + , Integer userIndex + , int timedInvokeTimeoutMs) { clearUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); } - public void clearWeekDaySchedule( - DefaultClusterCallback callback, Integer weekDayIndex, Integer userIndex) { + public void clearWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex) { clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); } - public void clearWeekDaySchedule( - DefaultClusterCallback callback, - Integer weekDayIndex, - Integer userIndex, - int timedInvokeTimeoutMs) { + public void clearWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); } - public void clearYearDaySchedule( - DefaultClusterCallback callback, Integer yearDayIndex, Integer userIndex) { + public void clearYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex) { clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); } - public void clearYearDaySchedule( - DefaultClusterCallback callback, - Integer yearDayIndex, - Integer userIndex, - int timedInvokeTimeoutMs) { + public void clearYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); } - public void getCredentialStatus( - GetCredentialStatusResponseCallback callback, - ChipStructs.DoorLockClusterDlCredential credential) { + public void getCredentialStatus(GetCredentialStatusResponseCallback callback + , ChipStructs.DoorLockClusterDlCredential credential) { getCredentialStatus(chipClusterPtr, callback, credential, null); } - public void getCredentialStatus( - GetCredentialStatusResponseCallback callback, - ChipStructs.DoorLockClusterDlCredential credential, - int timedInvokeTimeoutMs) { + public void getCredentialStatus(GetCredentialStatusResponseCallback callback + , ChipStructs.DoorLockClusterDlCredential credential + , int timedInvokeTimeoutMs) { getCredentialStatus(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); } - public void getUser(GetUserResponseCallback callback, Integer userIndex) { + public void getUser(GetUserResponseCallback callback + , Integer userIndex) { getUser(chipClusterPtr, callback, userIndex, null); } - public void getUser( - GetUserResponseCallback callback, Integer userIndex, int timedInvokeTimeoutMs) { + public void getUser(GetUserResponseCallback callback + , Integer userIndex + , int timedInvokeTimeoutMs) { getUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); } - public void getWeekDaySchedule( - GetWeekDayScheduleResponseCallback callback, Integer weekDayIndex, Integer userIndex) { + public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback + , Integer weekDayIndex, Integer userIndex) { getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); } - public void getWeekDaySchedule( - GetWeekDayScheduleResponseCallback callback, - Integer weekDayIndex, - Integer userIndex, - int timedInvokeTimeoutMs) { + public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback + , Integer weekDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); } - public void getYearDaySchedule( - GetYearDayScheduleResponseCallback callback, Integer yearDayIndex, Integer userIndex) { + public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback + , Integer yearDayIndex, Integer userIndex) { getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); } - public void getYearDaySchedule( - GetYearDayScheduleResponseCallback callback, - Integer yearDayIndex, - Integer userIndex, - int timedInvokeTimeoutMs) { + public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback + , Integer yearDayIndex, Integer userIndex + , int timedInvokeTimeoutMs) { getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); } - public void lockDoor( - DefaultClusterCallback callback, Optional pinCode, int timedInvokeTimeoutMs) { + + public void lockDoor(DefaultClusterCallback callback + , Optional pinCode + , int timedInvokeTimeoutMs) { lockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); } - public void setCredential( - SetCredentialResponseCallback callback, - Integer operationType, - ChipStructs.DoorLockClusterDlCredential credential, - byte[] credentialData, - @Nullable Integer userIndex, - @Nullable Integer userStatus, - @Nullable Integer userType, - int timedInvokeTimeoutMs) { - setCredential( - chipClusterPtr, - callback, - operationType, - credential, - credentialData, - userIndex, - userStatus, - userType, - timedInvokeTimeoutMs); - } - - public void setUser( - DefaultClusterCallback callback, - Integer operationType, - Integer userIndex, - @Nullable String userName, - @Nullable Long userUniqueId, - @Nullable Integer userStatus, - @Nullable Integer userType, - @Nullable Integer credentialRule, - int timedInvokeTimeoutMs) { - setUser( - chipClusterPtr, - callback, - operationType, - userIndex, - userName, - userUniqueId, - userStatus, - userType, - credentialRule, - timedInvokeTimeoutMs); - } - - public void setWeekDaySchedule( - DefaultClusterCallback callback, - Integer weekDayIndex, - Integer userIndex, - Integer daysMask, - Integer startHour, - Integer startMinute, - Integer endHour, - Integer endMinute) { - setWeekDaySchedule( - chipClusterPtr, - callback, - weekDayIndex, - userIndex, - daysMask, - startHour, - startMinute, - endHour, - endMinute, - null); - } - - public void setWeekDaySchedule( - DefaultClusterCallback callback, - Integer weekDayIndex, - Integer userIndex, - Integer daysMask, - Integer startHour, - Integer startMinute, - Integer endHour, - Integer endMinute, - int timedInvokeTimeoutMs) { - setWeekDaySchedule( - chipClusterPtr, - callback, - weekDayIndex, - userIndex, - daysMask, - startHour, - startMinute, - endHour, - endMinute, - timedInvokeTimeoutMs); - } - - public void setYearDaySchedule( - DefaultClusterCallback callback, - Integer yearDayIndex, - Integer userIndex, - Long localStartTime, - Long localEndTime) { - setYearDaySchedule( - chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null); - } - - public void setYearDaySchedule( - DefaultClusterCallback callback, - Integer yearDayIndex, - Integer userIndex, - Long localStartTime, - Long localEndTime, - int timedInvokeTimeoutMs) { - setYearDaySchedule( - chipClusterPtr, - callback, - yearDayIndex, - userIndex, - localStartTime, - localEndTime, - timedInvokeTimeoutMs); - } - - public void unlockDoor( - DefaultClusterCallback callback, Optional pinCode, int timedInvokeTimeoutMs) { - unlockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); + + public void setCredential(SetCredentialResponseCallback callback + , Integer operationType, ChipStructs.DoorLockClusterDlCredential credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType + , int timedInvokeTimeoutMs) { + setCredential(chipClusterPtr, callback, operationType, credential, credentialData, userIndex, userStatus, userType, timedInvokeTimeoutMs); } - public void unlockWithTimeout( - DefaultClusterCallback callback, - Integer timeout, - Optional pinCode, - int timedInvokeTimeoutMs) { - unlockWithTimeout(chipClusterPtr, callback, timeout, pinCode, timedInvokeTimeoutMs); + + public void setUser(DefaultClusterCallback callback + , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule + , int timedInvokeTimeoutMs) { + setUser(chipClusterPtr, callback, operationType, userIndex, userName, userUniqueId, userStatus, userType, credentialRule, timedInvokeTimeoutMs); } - private native void clearCredential( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable ChipStructs.DoorLockClusterDlCredential credential, - @Nullable Integer timedInvokeTimeoutMs); - - private native void clearUser( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void clearWeekDaySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer weekDayIndex, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void clearYearDaySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer yearDayIndex, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getCredentialStatus( - long chipClusterPtr, - GetCredentialStatusResponseCallback Callback, - ChipStructs.DoorLockClusterDlCredential credential, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getUser( - long chipClusterPtr, - GetUserResponseCallback Callback, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getWeekDaySchedule( - long chipClusterPtr, - GetWeekDayScheduleResponseCallback Callback, - Integer weekDayIndex, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getYearDaySchedule( - long chipClusterPtr, - GetYearDayScheduleResponseCallback Callback, - Integer yearDayIndex, - Integer userIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void lockDoor( - long chipClusterPtr, - DefaultClusterCallback Callback, - Optional pinCode, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setCredential( - long chipClusterPtr, - SetCredentialResponseCallback Callback, - Integer operationType, - ChipStructs.DoorLockClusterDlCredential credential, - byte[] credentialData, - @Nullable Integer userIndex, - @Nullable Integer userStatus, - @Nullable Integer userType, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setUser( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer operationType, - Integer userIndex, - @Nullable String userName, - @Nullable Long userUniqueId, - @Nullable Integer userStatus, - @Nullable Integer userType, - @Nullable Integer credentialRule, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setWeekDaySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer weekDayIndex, - Integer userIndex, - Integer daysMask, - Integer startHour, - Integer startMinute, - Integer endHour, - Integer endMinute, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setYearDaySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer yearDayIndex, - Integer userIndex, - Long localStartTime, - Long localEndTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void unlockDoor( - long chipClusterPtr, - DefaultClusterCallback Callback, - Optional pinCode, - @Nullable Integer timedInvokeTimeoutMs); - - private native void unlockWithTimeout( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer timeout, - Optional pinCode, - @Nullable Integer timedInvokeTimeoutMs); + public void setWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute) { + setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, null); + } + + public void setWeekDaySchedule(DefaultClusterCallback callback + , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute + , int timedInvokeTimeoutMs) { + setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, timedInvokeTimeoutMs); + } + + public void setYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime) { + setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null); + } + + public void setYearDaySchedule(DefaultClusterCallback callback + , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime + , int timedInvokeTimeoutMs) { + setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, timedInvokeTimeoutMs); + } + + + public void unlockDoor(DefaultClusterCallback callback + , Optional pinCode + , int timedInvokeTimeoutMs) { + unlockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); + } - public interface GetCredentialStatusResponseCallback { - void onSuccess( - Boolean credentialExists, - @Nullable Integer userIndex, - @Nullable Integer nextCredentialIndex); + public void unlockWithTimeout(DefaultClusterCallback callback + , Integer timeout, Optional pinCode + , int timedInvokeTimeoutMs) { + unlockWithTimeout(chipClusterPtr, callback, timeout, pinCode, timedInvokeTimeoutMs); + } + private native void clearCredential(long chipClusterPtr, DefaultClusterCallback Callback + , @Nullable ChipStructs.DoorLockClusterDlCredential credential + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearUser(long chipClusterPtr, DefaultClusterCallback Callback + , Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer weekDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void clearYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer yearDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void getCredentialStatus(long chipClusterPtr, GetCredentialStatusResponseCallback Callback + , ChipStructs.DoorLockClusterDlCredential credential + , @Nullable Integer timedInvokeTimeoutMs); + private native void getUser(long chipClusterPtr, GetUserResponseCallback Callback + , Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void getWeekDaySchedule(long chipClusterPtr, GetWeekDayScheduleResponseCallback Callback + , Integer weekDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void getYearDaySchedule(long chipClusterPtr, GetYearDayScheduleResponseCallback Callback + , Integer yearDayIndex, Integer userIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void lockDoor(long chipClusterPtr, DefaultClusterCallback Callback + , Optional pinCode + , @Nullable Integer timedInvokeTimeoutMs); + private native void setCredential(long chipClusterPtr, SetCredentialResponseCallback Callback + , Integer operationType, ChipStructs.DoorLockClusterDlCredential credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType + , @Nullable Integer timedInvokeTimeoutMs); + private native void setUser(long chipClusterPtr, DefaultClusterCallback Callback + , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule + , @Nullable Integer timedInvokeTimeoutMs); + private native void setWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute + , @Nullable Integer timedInvokeTimeoutMs); + private native void setYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void unlockDoor(long chipClusterPtr, DefaultClusterCallback Callback + , Optional pinCode + , @Nullable Integer timedInvokeTimeoutMs); + private native void unlockWithTimeout(long chipClusterPtr, DefaultClusterCallback Callback + , Integer timeout, Optional pinCode + , @Nullable Integer timedInvokeTimeoutMs); + public interface GetCredentialStatusResponseCallback { + void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); + void onError(Exception error); } public interface GetUserResponseCallback { - void onSuccess( - Integer userIndex, - @Nullable String userName, - @Nullable Long userUniqueId, - @Nullable Integer userStatus, - @Nullable Integer userType, - @Nullable Integer credentialRule, - @Nullable ArrayList credentials, - @Nullable Integer creatorFabricIndex, - @Nullable Integer lastModifiedFabricIndex, - @Nullable Integer nextUserIndex); - + void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex); + void onError(Exception error); } public interface GetWeekDayScheduleResponseCallback { - void onSuccess( - Integer weekDayIndex, - Integer userIndex, - Integer status, - Optional daysMask, - Optional startHour, - Optional startMinute, - Optional endHour, - Optional endMinute); - + void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute); + void onError(Exception error); } public interface GetYearDayScheduleResponseCallback { - void onSuccess( - Integer yearDayIndex, - Integer userIndex, - Integer status, - Optional localStartTime, - Optional localEndTime); - + void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime); + void onError(Exception error); } public interface SetCredentialResponseCallback { - void onSuccess( - Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); - + void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); + void onError(Exception error); } - public interface LockStateAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); + public interface LockStateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface DoorStateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - default void onSubscriptionEstablished() {} - } - - public interface DoorStateAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readLockStateAttribute(LockStateAttributeCallback callback) { + public void readLockStateAttribute( + LockStateAttributeCallback callback + ) { readLockStateAttribute(chipClusterPtr, callback); } - public void subscribeLockStateAttribute( - LockStateAttributeCallback callback, int minInterval, int maxInterval) { + LockStateAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLockStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLockTypeAttribute(IntegerAttributeCallback callback) { + public void readLockTypeAttribute( + IntegerAttributeCallback callback + ) { readLockTypeAttribute(chipClusterPtr, callback); } - public void subscribeLockTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLockTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActuatorEnabledAttribute(BooleanAttributeCallback callback) { + public void readActuatorEnabledAttribute( + BooleanAttributeCallback callback + ) { readActuatorEnabledAttribute(chipClusterPtr, callback); } - public void subscribeActuatorEnabledAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActuatorEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDoorStateAttribute(DoorStateAttributeCallback callback) { + public void readDoorStateAttribute( + DoorStateAttributeCallback callback + ) { readDoorStateAttribute(chipClusterPtr, callback); } - public void subscribeDoorStateAttribute( - DoorStateAttributeCallback callback, int minInterval, int maxInterval) { + DoorStateAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeDoorStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfTotalUsersSupportedAttribute(IntegerAttributeCallback callback) { + public void readNumberOfTotalUsersSupportedAttribute( + IntegerAttributeCallback callback + ) { readNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfTotalUsersSupportedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfTotalUsersSupportedAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfPINUsersSupportedAttribute(IntegerAttributeCallback callback) { + public void readNumberOfPINUsersSupportedAttribute( + IntegerAttributeCallback callback + ) { readNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfPINUsersSupportedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfPINUsersSupportedAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfRFIDUsersSupportedAttribute(IntegerAttributeCallback callback) { + public void readNumberOfRFIDUsersSupportedAttribute( + IntegerAttributeCallback callback + ) { readNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfRFIDUsersSupportedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfRFIDUsersSupportedAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNumberOfWeekDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback) { + IntegerAttributeCallback callback + ) { readNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNumberOfYearDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback) { + IntegerAttributeCallback callback + ) { readNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxPINCodeLengthAttribute(IntegerAttributeCallback callback) { + public void readMaxPINCodeLengthAttribute( + IntegerAttributeCallback callback + ) { readMaxPINCodeLengthAttribute(chipClusterPtr, callback); } - public void subscribeMaxPINCodeLengthAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinPINCodeLengthAttribute(IntegerAttributeCallback callback) { + public void readMinPINCodeLengthAttribute( + IntegerAttributeCallback callback + ) { readMinPINCodeLengthAttribute(chipClusterPtr, callback); } - public void subscribeMinPINCodeLengthAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxRFIDCodeLengthAttribute(IntegerAttributeCallback callback) { + public void readMaxRFIDCodeLengthAttribute( + IntegerAttributeCallback callback + ) { readMaxRFIDCodeLengthAttribute(chipClusterPtr, callback); } - public void subscribeMaxRFIDCodeLengthAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinRFIDCodeLengthAttribute(IntegerAttributeCallback callback) { + public void readMinRFIDCodeLengthAttribute( + IntegerAttributeCallback callback + ) { readMinRFIDCodeLengthAttribute(chipClusterPtr, callback); } - public void subscribeMinRFIDCodeLengthAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLanguageAttribute(CharStringAttributeCallback callback) { + public void readLanguageAttribute( + CharStringAttributeCallback callback + ) { readLanguageAttribute(chipClusterPtr, callback); } - public void writeLanguageAttribute(DefaultClusterCallback callback, String value) { writeLanguageAttribute(chipClusterPtr, callback, value, null); } - public void writeLanguageAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLanguageAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLanguageAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLanguageAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLanguageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAutoRelockTimeAttribute(LongAttributeCallback callback) { + public void readAutoRelockTimeAttribute( + LongAttributeCallback callback + ) { readAutoRelockTimeAttribute(chipClusterPtr, callback); } - public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value) { writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeAutoRelockTimeAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeAutoRelockTimeAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAutoRelockTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoundVolumeAttribute(IntegerAttributeCallback callback) { + public void readSoundVolumeAttribute( + IntegerAttributeCallback callback + ) { readSoundVolumeAttribute(chipClusterPtr, callback); } - public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value) { writeSoundVolumeAttribute(chipClusterPtr, callback, value, null); } - public void writeSoundVolumeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSoundVolumeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeSoundVolumeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSoundVolumeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperatingModeAttribute(IntegerAttributeCallback callback) { + public void readOperatingModeAttribute( + IntegerAttributeCallback callback + ) { readOperatingModeAttribute(chipClusterPtr, callback); } - public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value) { writeOperatingModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOperatingModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOperatingModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOperatingModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOperatingModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedOperatingModesAttribute(IntegerAttributeCallback callback) { + public void readSupportedOperatingModesAttribute( + IntegerAttributeCallback callback + ) { readSupportedOperatingModesAttribute(chipClusterPtr, callback); } - public void subscribeSupportedOperatingModesAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSupportedOperatingModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnableOneTouchLockingAttribute(BooleanAttributeCallback callback) { + public void readEnableOneTouchLockingAttribute( + BooleanAttributeCallback callback + ) { readEnableOneTouchLockingAttribute(chipClusterPtr, callback); } - - public void writeEnableOneTouchLockingAttribute( - DefaultClusterCallback callback, Boolean value) { + public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value) { writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, null); } - public void writeEnableOneTouchLockingAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEnableOneTouchLockingAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnableOneTouchLockingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnablePrivacyModeButtonAttribute(BooleanAttributeCallback callback) { + public void readEnablePrivacyModeButtonAttribute( + BooleanAttributeCallback callback + ) { readEnablePrivacyModeButtonAttribute(chipClusterPtr, callback); } - - public void writeEnablePrivacyModeButtonAttribute( - DefaultClusterCallback callback, Boolean value) { + public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value) { writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, null); } - public void writeEnablePrivacyModeButtonAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEnablePrivacyModeButtonAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWrongCodeEntryLimitAttribute(IntegerAttributeCallback callback) { + public void readWrongCodeEntryLimitAttribute( + IntegerAttributeCallback callback + ) { readWrongCodeEntryLimitAttribute(chipClusterPtr, callback); } - public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value) { writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeWrongCodeEntryLimitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeWrongCodeEntryLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLockStateAttribute( - long chipClusterPtr, LockStateAttributeCallback callback); - - private native void subscribeLockStateAttribute( - long chipClusterPtr, LockStateAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLockTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLockTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActuatorEnabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeActuatorEnabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDoorStateAttribute( - long chipClusterPtr, DoorStateAttributeCallback callback); - - private native void subscribeDoorStateAttribute( - long chipClusterPtr, DoorStateAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfTotalUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfTotalUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfPINUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfPINUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfRFIDUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfRFIDUsersSupportedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfWeekDaySchedulesSupportedPerUserAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfYearDaySchedulesSupportedPerUserAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxPINCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxPINCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinPINCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinPINCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxRFIDCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxRFIDCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinRFIDCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinRFIDCodeLengthAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLanguageAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeLanguageAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLanguageAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readAutoRelockTimeAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void writeAutoRelockTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeAutoRelockTimeAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSoundVolumeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeSoundVolumeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeSoundVolumeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOperatingModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOperatingModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOperatingModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSupportedOperatingModesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSupportedOperatingModesAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnableOneTouchLockingAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeEnableOneTouchLockingAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEnableOneTouchLockingAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnablePrivacyModeButtonAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeEnablePrivacyModeButtonAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEnablePrivacyModeButtonAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readWrongCodeEntryLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeWrongCodeEntryLimitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeWrongCodeEntryLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readLockStateAttribute(long chipClusterPtr, + LockStateAttributeCallback callback + ); + private native void subscribeLockStateAttribute(long chipClusterPtr, + LockStateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLockTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLockTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActuatorEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeActuatorEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDoorStateAttribute(long chipClusterPtr, + DoorStateAttributeCallback callback + ); + private native void subscribeDoorStateAttribute(long chipClusterPtr, + DoorStateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfPINUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfPINUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinPINCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinRFIDCodeLengthAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLanguageAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeLanguageAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLanguageAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAutoRelockTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeAutoRelockTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeAutoRelockTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSoundVolumeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeSoundVolumeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSoundVolumeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOperatingModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOperatingModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOperatingModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedOperatingModesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSupportedOperatingModesAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnableOneTouchLockingAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeEnableOneTouchLockingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnableOneTouchLockingAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnablePrivacyModeButtonAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeEnablePrivacyModeButtonAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnablePrivacyModeButtonAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWrongCodeEntryLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeWrongCodeEntryLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeWrongCodeEntryLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ElectricalMeasurementCluster extends BaseChipCluster { @@ -5556,211 +4792,258 @@ public ElectricalMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMeasurementTypeAttribute(LongAttributeCallback callback) { + public void readMeasurementTypeAttribute( + LongAttributeCallback callback + ) { readMeasurementTypeAttribute(chipClusterPtr, callback); } - public void subscribeMeasurementTypeAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMeasurementTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTotalActivePowerAttribute(LongAttributeCallback callback) { + public void readTotalActivePowerAttribute( + LongAttributeCallback callback + ) { readTotalActivePowerAttribute(chipClusterPtr, callback); } - public void subscribeTotalActivePowerAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTotalActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageAttribute(IntegerAttributeCallback callback) { + public void readRmsVoltageAttribute( + IntegerAttributeCallback callback + ) { readRmsVoltageAttribute(chipClusterPtr, callback); } - public void subscribeRmsVoltageAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageMinAttribute(IntegerAttributeCallback callback) { + public void readRmsVoltageMinAttribute( + IntegerAttributeCallback callback + ) { readRmsVoltageMinAttribute(chipClusterPtr, callback); } - public void subscribeRmsVoltageMinAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsVoltageMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageMaxAttribute(IntegerAttributeCallback callback) { + public void readRmsVoltageMaxAttribute( + IntegerAttributeCallback callback + ) { readRmsVoltageMaxAttribute(chipClusterPtr, callback); } - public void subscribeRmsVoltageMaxAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsVoltageMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentAttribute(IntegerAttributeCallback callback) { + public void readRmsCurrentAttribute( + IntegerAttributeCallback callback + ) { readRmsCurrentAttribute(chipClusterPtr, callback); } - public void subscribeRmsCurrentAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentMinAttribute(IntegerAttributeCallback callback) { + public void readRmsCurrentMinAttribute( + IntegerAttributeCallback callback + ) { readRmsCurrentMinAttribute(chipClusterPtr, callback); } - public void subscribeRmsCurrentMinAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsCurrentMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentMaxAttribute(IntegerAttributeCallback callback) { + public void readRmsCurrentMaxAttribute( + IntegerAttributeCallback callback + ) { readRmsCurrentMaxAttribute(chipClusterPtr, callback); } - public void subscribeRmsCurrentMaxAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRmsCurrentMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerAttribute(IntegerAttributeCallback callback) { + public void readActivePowerAttribute( + IntegerAttributeCallback callback + ) { readActivePowerAttribute(chipClusterPtr, callback); } - public void subscribeActivePowerAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerMinAttribute(IntegerAttributeCallback callback) { + public void readActivePowerMinAttribute( + IntegerAttributeCallback callback + ) { readActivePowerMinAttribute(chipClusterPtr, callback); } - public void subscribeActivePowerMinAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActivePowerMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerMaxAttribute(IntegerAttributeCallback callback) { + public void readActivePowerMaxAttribute( + IntegerAttributeCallback callback + ) { readActivePowerMaxAttribute(chipClusterPtr, callback); } - public void subscribeActivePowerMaxAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActivePowerMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasurementTypeAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeMeasurementTypeAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTotalActivePowerAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTotalActivePowerAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsVoltageAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsVoltageAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsVoltageMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsVoltageMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsVoltageMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsVoltageMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsCurrentAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsCurrentAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsCurrentMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsCurrentMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRmsCurrentMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRmsCurrentMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActivePowerAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeActivePowerAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActivePowerMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeActivePowerMinAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActivePowerMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeActivePowerMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMeasurementTypeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeMeasurementTypeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTotalActivePowerAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTotalActivePowerAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsVoltageMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsVoltageMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRmsCurrentMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRmsCurrentMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerMinAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActivePowerMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeActivePowerMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class EthernetNetworkDiagnosticsCluster extends BaseChipCluster { @@ -5773,210 +5056,253 @@ public EthernetNetworkDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetCounts(DefaultClusterCallback callback) { + public void resetCounts(DefaultClusterCallback callback + ) { resetCounts(chipClusterPtr, callback, null); } - public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void resetCounts(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); - private native void resetCounts( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readPHYRateAttribute(IntegerAttributeCallback callback) { + public void readPHYRateAttribute( + IntegerAttributeCallback callback + ) { readPHYRateAttribute(chipClusterPtr, callback); } - public void subscribePHYRateAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePHYRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFullDuplexAttribute(BooleanAttributeCallback callback) { + public void readFullDuplexAttribute( + BooleanAttributeCallback callback + ) { readFullDuplexAttribute(chipClusterPtr, callback); } - public void subscribeFullDuplexAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFullDuplexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketRxCountAttribute(LongAttributeCallback callback) { + public void readPacketRxCountAttribute( + LongAttributeCallback callback + ) { readPacketRxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketRxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketTxCountAttribute(LongAttributeCallback callback) { + public void readPacketTxCountAttribute( + LongAttributeCallback callback + ) { readPacketTxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketTxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrCountAttribute(LongAttributeCallback callback) { + public void readTxErrCountAttribute( + LongAttributeCallback callback + ) { readTxErrCountAttribute(chipClusterPtr, callback); } - public void subscribeTxErrCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxErrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCollisionCountAttribute(LongAttributeCallback callback) { + public void readCollisionCountAttribute( + LongAttributeCallback callback + ) { readCollisionCountAttribute(chipClusterPtr, callback); } - public void subscribeCollisionCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCollisionCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute(LongAttributeCallback callback) { + public void readOverrunCountAttribute( + LongAttributeCallback callback + ) { readOverrunCountAttribute(chipClusterPtr, callback); } - public void subscribeOverrunCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCarrierDetectAttribute(BooleanAttributeCallback callback) { + public void readCarrierDetectAttribute( + BooleanAttributeCallback callback + ) { readCarrierDetectAttribute(chipClusterPtr, callback); } - public void subscribeCarrierDetectAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCarrierDetectAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTimeSinceResetAttribute(LongAttributeCallback callback) { + public void readTimeSinceResetAttribute( + LongAttributeCallback callback + ) { readTimeSinceResetAttribute(chipClusterPtr, callback); } - public void subscribeTimeSinceResetAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTimeSinceResetAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readPHYRateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePHYRateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readFullDuplexAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeFullDuplexAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxErrCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxErrCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCollisionCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeCollisionCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCarrierDetectAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeCarrierDetectAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTimeSinceResetAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTimeSinceResetAttribute( - long chipClusterPtr, LongAttributeCallback 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); + private native void readPHYRateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePHYRateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readFullDuplexAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeFullDuplexAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCollisionCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCollisionCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCarrierDetectAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeCarrierDetectAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTimeSinceResetAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTimeSinceResetAttribute(long chipClusterPtr, + LongAttributeCallback 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 FixedLabelCluster extends BaseChipCluster { @@ -5989,69 +5315,73 @@ public FixedLabelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LabelListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface LabelListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readLabelListAttribute(LabelListAttributeCallback callback) { + public void readLabelListAttribute( + LabelListAttributeCallback callback + ) { readLabelListAttribute(chipClusterPtr, callback); } - public void subscribeLabelListAttribute( - LabelListAttributeCallback callback, int minInterval, int maxInterval) { + LabelListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLabelListAttribute( - long chipClusterPtr, LabelListAttributeCallback callback); - - private native void subscribeLabelListAttribute( - long chipClusterPtr, LabelListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback callback + ); + private native void subscribeLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class FlowMeasurementCluster extends BaseChipCluster { @@ -6064,106 +5394,125 @@ public FlowMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMinMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMaxMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute(IntegerAttributeCallback callback) { + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { readToleranceAttribute(chipClusterPtr, callback); } - public void subscribeToleranceAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class GeneralCommissioningCluster extends BaseChipCluster { @@ -6176,235 +5525,199 @@ public GeneralCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void armFailSafe( - ArmFailSafeResponseCallback callback, - Integer expiryLengthSeconds, - Long breadcrumb, - Long timeoutMs) { + public void armFailSafe(ArmFailSafeResponseCallback callback + , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs) { armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timeoutMs, null); } - public void armFailSafe( - ArmFailSafeResponseCallback callback, - Integer expiryLengthSeconds, - Long breadcrumb, - Long timeoutMs, - int timedInvokeTimeoutMs) { - armFailSafe( - chipClusterPtr, - callback, - expiryLengthSeconds, - breadcrumb, - timeoutMs, - timedInvokeTimeoutMs); + public void armFailSafe(ArmFailSafeResponseCallback callback + , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs + , int timedInvokeTimeoutMs) { + armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timeoutMs, timedInvokeTimeoutMs); } - public void commissioningComplete(CommissioningCompleteResponseCallback callback) { + public void commissioningComplete(CommissioningCompleteResponseCallback callback + ) { commissioningComplete(chipClusterPtr, callback, null); } - public void commissioningComplete( - CommissioningCompleteResponseCallback callback, int timedInvokeTimeoutMs) { - + public void commissioningComplete(CommissioningCompleteResponseCallback callback + + , int timedInvokeTimeoutMs) { commissioningComplete(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void setRegulatoryConfig( - SetRegulatoryConfigResponseCallback callback, - Integer location, - String countryCode, - Long breadcrumb, - Long timeoutMs) { - setRegulatoryConfig( - chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, null); - } - - public void setRegulatoryConfig( - SetRegulatoryConfigResponseCallback callback, - Integer location, - String countryCode, - Long breadcrumb, - Long timeoutMs, - int timedInvokeTimeoutMs) { - setRegulatoryConfig( - chipClusterPtr, - callback, - location, - countryCode, - breadcrumb, - timeoutMs, - timedInvokeTimeoutMs); - } - - private native void armFailSafe( - long chipClusterPtr, - ArmFailSafeResponseCallback Callback, - Integer expiryLengthSeconds, - Long breadcrumb, - Long timeoutMs, - @Nullable Integer timedInvokeTimeoutMs); - - private native void commissioningComplete( - long chipClusterPtr, - CommissioningCompleteResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setRegulatoryConfig( - long chipClusterPtr, - SetRegulatoryConfigResponseCallback Callback, - Integer location, - String countryCode, - Long breadcrumb, - Long timeoutMs, - @Nullable Integer timedInvokeTimeoutMs); + public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback + , Integer location, String countryCode, Long breadcrumb, Long timeoutMs) { + setRegulatoryConfig(chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, null); + } + public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback + , Integer location, String countryCode, Long breadcrumb, Long timeoutMs + , int timedInvokeTimeoutMs) { + setRegulatoryConfig(chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, timedInvokeTimeoutMs); + } + private native void armFailSafe(long chipClusterPtr, ArmFailSafeResponseCallback Callback + , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs + , @Nullable Integer timedInvokeTimeoutMs); + private native void commissioningComplete(long chipClusterPtr, CommissioningCompleteResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void setRegulatoryConfig(long chipClusterPtr, SetRegulatoryConfigResponseCallback Callback + , Integer location, String countryCode, Long breadcrumb, Long timeoutMs + , @Nullable Integer timedInvokeTimeoutMs); public interface ArmFailSafeResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } public interface CommissioningCompleteResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } public interface SetRegulatoryConfigResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } - public interface BasicCommissioningInfoListAttributeCallback { - void onSuccess( - List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface BasicCommissioningInfoListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readBreadcrumbAttribute(LongAttributeCallback callback) { + public void readBreadcrumbAttribute( + LongAttributeCallback callback + ) { readBreadcrumbAttribute(chipClusterPtr, callback); } - public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value) { writeBreadcrumbAttribute(chipClusterPtr, callback, value, null); } - public void writeBreadcrumbAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBreadcrumbAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBreadcrumbAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBreadcrumbAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readBasicCommissioningInfoListAttribute( - BasicCommissioningInfoListAttributeCallback callback) { + BasicCommissioningInfoListAttributeCallback callback + ) { readBasicCommissioningInfoListAttribute(chipClusterPtr, callback); } - public void subscribeBasicCommissioningInfoListAttribute( - BasicCommissioningInfoListAttributeCallback callback, int minInterval, int maxInterval) { - subscribeBasicCommissioningInfoListAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + BasicCommissioningInfoListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeBasicCommissioningInfoListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRegulatoryConfigAttribute(IntegerAttributeCallback callback) { + public void readRegulatoryConfigAttribute( + IntegerAttributeCallback callback + ) { readRegulatoryConfigAttribute(chipClusterPtr, callback); } - public void subscribeRegulatoryConfigAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRegulatoryConfigAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocationCapabilityAttribute(IntegerAttributeCallback callback) { + public void readLocationCapabilityAttribute( + IntegerAttributeCallback callback + ) { readLocationCapabilityAttribute(chipClusterPtr, callback); } - public void subscribeLocationCapabilityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLocationCapabilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBreadcrumbAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void writeBreadcrumbAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBreadcrumbAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBasicCommissioningInfoListAttribute( - long chipClusterPtr, BasicCommissioningInfoListAttributeCallback callback); - - private native void subscribeBasicCommissioningInfoListAttribute( - long chipClusterPtr, - BasicCommissioningInfoListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readRegulatoryConfigAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRegulatoryConfigAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLocationCapabilityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLocationCapabilityAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readBreadcrumbAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeBreadcrumbAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBreadcrumbAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBasicCommissioningInfoListAttribute(long chipClusterPtr, + BasicCommissioningInfoListAttributeCallback callback + ); + private native void subscribeBasicCommissioningInfoListAttribute(long chipClusterPtr, + BasicCommissioningInfoListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRegulatoryConfigAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRegulatoryConfigAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLocationCapabilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLocationCapabilityAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class GeneralDiagnosticsCluster extends BaseChipCluster { @@ -6417,209 +5730,221 @@ public GeneralDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface NetworkInterfacesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); + public interface NetworkInterfacesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ActiveHardwareFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ActiveRadioFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ActiveNetworkFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - default void onSubscriptionEstablished() {} + public void readNetworkInterfacesAttribute( + NetworkInterfacesAttributeCallback callback + ) { + readNetworkInterfacesAttribute(chipClusterPtr, callback); + } + public void subscribeNetworkInterfacesAttribute( + NetworkInterfacesAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public interface ActiveHardwareFaultsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ActiveRadioFaultsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ActiveNetworkFaultsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readNetworkInterfacesAttribute(NetworkInterfacesAttributeCallback callback) { - readNetworkInterfacesAttribute(chipClusterPtr, callback); - } - - public void subscribeNetworkInterfacesAttribute( - NetworkInterfacesAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readRebootCountAttribute(IntegerAttributeCallback callback) { + public void readRebootCountAttribute( + IntegerAttributeCallback callback + ) { readRebootCountAttribute(chipClusterPtr, callback); } - public void subscribeRebootCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRebootCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpTimeAttribute(LongAttributeCallback callback) { + public void readUpTimeAttribute( + LongAttributeCallback callback + ) { readUpTimeAttribute(chipClusterPtr, callback); } - public void subscribeUpTimeAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeUpTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTotalOperationalHoursAttribute(LongAttributeCallback callback) { + public void readTotalOperationalHoursAttribute( + LongAttributeCallback callback + ) { readTotalOperationalHoursAttribute(chipClusterPtr, callback); } - public void subscribeTotalOperationalHoursAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTotalOperationalHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBootReasonsAttribute(IntegerAttributeCallback callback) { + public void readBootReasonsAttribute( + IntegerAttributeCallback callback + ) { readBootReasonsAttribute(chipClusterPtr, callback); } - public void subscribeBootReasonsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBootReasonsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveHardwareFaultsAttribute(ActiveHardwareFaultsAttributeCallback callback) { + public void readActiveHardwareFaultsAttribute( + ActiveHardwareFaultsAttributeCallback callback + ) { readActiveHardwareFaultsAttribute(chipClusterPtr, callback); } - public void subscribeActiveHardwareFaultsAttribute( - ActiveHardwareFaultsAttributeCallback callback, int minInterval, int maxInterval) { + ActiveHardwareFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeActiveHardwareFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveRadioFaultsAttribute(ActiveRadioFaultsAttributeCallback callback) { + public void readActiveRadioFaultsAttribute( + ActiveRadioFaultsAttributeCallback callback + ) { readActiveRadioFaultsAttribute(chipClusterPtr, callback); } - public void subscribeActiveRadioFaultsAttribute( - ActiveRadioFaultsAttributeCallback callback, int minInterval, int maxInterval) { + ActiveRadioFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeActiveRadioFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveNetworkFaultsAttribute(ActiveNetworkFaultsAttributeCallback callback) { + public void readActiveNetworkFaultsAttribute( + ActiveNetworkFaultsAttributeCallback callback + ) { readActiveNetworkFaultsAttribute(chipClusterPtr, callback); } - public void subscribeActiveNetworkFaultsAttribute( - ActiveNetworkFaultsAttributeCallback callback, int minInterval, int maxInterval) { + ActiveNetworkFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeActiveNetworkFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNetworkInterfacesAttribute( - long chipClusterPtr, NetworkInterfacesAttributeCallback callback); - - private native void subscribeNetworkInterfacesAttribute( - long chipClusterPtr, - NetworkInterfacesAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readRebootCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRebootCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readUpTimeAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeUpTimeAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTotalOperationalHoursAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTotalOperationalHoursAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBootReasonsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBootReasonsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActiveHardwareFaultsAttribute( - long chipClusterPtr, ActiveHardwareFaultsAttributeCallback callback); - - private native void subscribeActiveHardwareFaultsAttribute( - long chipClusterPtr, - ActiveHardwareFaultsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readActiveRadioFaultsAttribute( - long chipClusterPtr, ActiveRadioFaultsAttributeCallback callback); - - private native void subscribeActiveRadioFaultsAttribute( - long chipClusterPtr, - ActiveRadioFaultsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readActiveNetworkFaultsAttribute( - long chipClusterPtr, ActiveNetworkFaultsAttributeCallback callback); - - private native void subscribeActiveNetworkFaultsAttribute( - long chipClusterPtr, - ActiveNetworkFaultsAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readNetworkInterfacesAttribute(long chipClusterPtr, + NetworkInterfacesAttributeCallback callback + ); + private native void subscribeNetworkInterfacesAttribute(long chipClusterPtr, + NetworkInterfacesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRebootCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRebootCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUpTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeUpTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTotalOperationalHoursAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTotalOperationalHoursAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBootReasonsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBootReasonsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveHardwareFaultsAttribute(long chipClusterPtr, + ActiveHardwareFaultsAttributeCallback callback + ); + private native void subscribeActiveHardwareFaultsAttribute(long chipClusterPtr, + ActiveHardwareFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readActiveRadioFaultsAttribute(long chipClusterPtr, + ActiveRadioFaultsAttributeCallback callback + ); + private native void subscribeActiveRadioFaultsAttribute(long chipClusterPtr, + ActiveRadioFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readActiveNetworkFaultsAttribute(long chipClusterPtr, + ActiveNetworkFaultsAttributeCallback callback + ); + private native void subscribeActiveNetworkFaultsAttribute(long chipClusterPtr, + ActiveNetworkFaultsAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class GroupKeyManagementCluster extends BaseChipCluster { @@ -6632,207 +5957,203 @@ public GroupKeyManagementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void keySetRead(KeySetReadResponseCallback callback, Integer groupKeySetID) { + public void keySetRead(KeySetReadResponseCallback callback + , Integer groupKeySetID) { keySetRead(chipClusterPtr, callback, groupKeySetID, null); } - public void keySetRead( - KeySetReadResponseCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) { + public void keySetRead(KeySetReadResponseCallback callback + , Integer groupKeySetID + , int timedInvokeTimeoutMs) { keySetRead(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); } - public void keySetReadAllIndices( - KeySetReadAllIndicesResponseCallback callback, ArrayList groupKeySetIDs) { + public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback + , ArrayList groupKeySetIDs) { keySetReadAllIndices(chipClusterPtr, callback, groupKeySetIDs, null); } - public void keySetReadAllIndices( - KeySetReadAllIndicesResponseCallback callback, - ArrayList groupKeySetIDs, - int timedInvokeTimeoutMs) { + public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback + , ArrayList groupKeySetIDs + , int timedInvokeTimeoutMs) { keySetReadAllIndices(chipClusterPtr, callback, groupKeySetIDs, timedInvokeTimeoutMs); } - public void keySetRemove(DefaultClusterCallback callback, Integer groupKeySetID) { + public void keySetRemove(DefaultClusterCallback callback + , Integer groupKeySetID) { keySetRemove(chipClusterPtr, callback, groupKeySetID, null); } - public void keySetRemove( - DefaultClusterCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) { + public void keySetRemove(DefaultClusterCallback callback + , Integer groupKeySetID + , int timedInvokeTimeoutMs) { keySetRemove(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); } - public void keySetWrite( - DefaultClusterCallback callback, - ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { + public void keySetWrite(DefaultClusterCallback callback + , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { keySetWrite(chipClusterPtr, callback, groupKeySet, null); } - public void keySetWrite( - DefaultClusterCallback callback, - ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet, - int timedInvokeTimeoutMs) { + public void keySetWrite(DefaultClusterCallback callback + , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet + , int timedInvokeTimeoutMs) { keySetWrite(chipClusterPtr, callback, groupKeySet, timedInvokeTimeoutMs); } - - private native void keySetRead( - long chipClusterPtr, - KeySetReadResponseCallback Callback, - Integer groupKeySetID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void keySetReadAllIndices( - long chipClusterPtr, - KeySetReadAllIndicesResponseCallback Callback, - ArrayList groupKeySetIDs, - @Nullable Integer timedInvokeTimeoutMs); - - private native void keySetRemove( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer groupKeySetID, - @Nullable Integer timedInvokeTimeoutMs); - - private native void keySetWrite( - long chipClusterPtr, - DefaultClusterCallback Callback, - ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet, - @Nullable Integer timedInvokeTimeoutMs); - + private native void keySetRead(long chipClusterPtr, KeySetReadResponseCallback Callback + , Integer groupKeySetID + , @Nullable Integer timedInvokeTimeoutMs); + private native void keySetReadAllIndices(long chipClusterPtr, KeySetReadAllIndicesResponseCallback Callback + , ArrayList groupKeySetIDs + , @Nullable Integer timedInvokeTimeoutMs); + private native void keySetRemove(long chipClusterPtr, DefaultClusterCallback Callback + , Integer groupKeySetID + , @Nullable Integer timedInvokeTimeoutMs); + private native void keySetWrite(long chipClusterPtr, DefaultClusterCallback Callback + , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet + , @Nullable Integer timedInvokeTimeoutMs); public interface KeySetReadAllIndicesResponseCallback { void onSuccess(ArrayList groupKeySetIDs); - + void onError(Exception error); } public interface KeySetReadResponseCallback { void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet); - + void onError(Exception error); } - public interface GroupKeyMapAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface GroupTableAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface GroupKeyMapAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface GroupTableAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readGroupKeyMapAttribute(GroupKeyMapAttributeCallback callback) { + public void readGroupKeyMapAttribute( + GroupKeyMapAttributeCallback callback + ) { readGroupKeyMapAttribute(chipClusterPtr, callback); } - public void subscribeGroupKeyMapAttribute( - GroupKeyMapAttributeCallback callback, int minInterval, int maxInterval) { + GroupKeyMapAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeGroupKeyMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGroupTableAttribute(GroupTableAttributeCallback callback) { + public void readGroupTableAttribute( + GroupTableAttributeCallback callback + ) { readGroupTableAttribute(chipClusterPtr, callback); } - public void subscribeGroupTableAttribute( - GroupTableAttributeCallback callback, int minInterval, int maxInterval) { + GroupTableAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeGroupTableAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxGroupsPerFabricAttribute(IntegerAttributeCallback callback) { + public void readMaxGroupsPerFabricAttribute( + IntegerAttributeCallback callback + ) { readMaxGroupsPerFabricAttribute(chipClusterPtr, callback); } - public void subscribeMaxGroupsPerFabricAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxGroupsPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxGroupKeysPerFabricAttribute(IntegerAttributeCallback callback) { + public void readMaxGroupKeysPerFabricAttribute( + IntegerAttributeCallback callback + ) { readMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback); } - public void subscribeMaxGroupKeysPerFabricAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readGroupKeyMapAttribute( - long chipClusterPtr, GroupKeyMapAttributeCallback callback); - - private native void subscribeGroupKeyMapAttribute( - long chipClusterPtr, - GroupKeyMapAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readGroupTableAttribute( - long chipClusterPtr, GroupTableAttributeCallback callback); - - private native void subscribeGroupTableAttribute( - long chipClusterPtr, - GroupTableAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readMaxGroupsPerFabricAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxGroupsPerFabricAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxGroupKeysPerFabricAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxGroupKeysPerFabricAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readGroupKeyMapAttribute(long chipClusterPtr, + GroupKeyMapAttributeCallback callback + ); + private native void subscribeGroupKeyMapAttribute(long chipClusterPtr, + GroupKeyMapAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readGroupTableAttribute(long chipClusterPtr, + GroupTableAttributeCallback callback + ); + private native void subscribeGroupTableAttribute(long chipClusterPtr, + GroupTableAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxGroupsPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxGroupsPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxGroupKeysPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxGroupKeysPerFabricAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class GroupsCluster extends BaseChipCluster { @@ -6845,186 +6166,176 @@ public GroupsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addGroup(AddGroupResponseCallback callback, Integer groupId, String groupName) { + public void addGroup(AddGroupResponseCallback callback + , Integer groupId, String groupName) { addGroup(chipClusterPtr, callback, groupId, groupName, null); } - public void addGroup( - AddGroupResponseCallback callback, - Integer groupId, - String groupName, - int timedInvokeTimeoutMs) { + public void addGroup(AddGroupResponseCallback callback + , Integer groupId, String groupName + , int timedInvokeTimeoutMs) { addGroup(chipClusterPtr, callback, groupId, groupName, timedInvokeTimeoutMs); } - public void addGroupIfIdentifying( - DefaultClusterCallback callback, Integer groupId, String groupName) { + public void addGroupIfIdentifying(DefaultClusterCallback callback + , Integer groupId, String groupName) { addGroupIfIdentifying(chipClusterPtr, callback, groupId, groupName, null); } - public void addGroupIfIdentifying( - DefaultClusterCallback callback, - Integer groupId, - String groupName, - int timedInvokeTimeoutMs) { + public void addGroupIfIdentifying(DefaultClusterCallback callback + , Integer groupId, String groupName + , int timedInvokeTimeoutMs) { addGroupIfIdentifying(chipClusterPtr, callback, groupId, groupName, timedInvokeTimeoutMs); } - public void getGroupMembership( - GetGroupMembershipResponseCallback callback, ArrayList groupList) { + public void getGroupMembership(GetGroupMembershipResponseCallback callback + , ArrayList groupList) { getGroupMembership(chipClusterPtr, callback, groupList, null); } - public void getGroupMembership( - GetGroupMembershipResponseCallback callback, - ArrayList groupList, - int timedInvokeTimeoutMs) { + public void getGroupMembership(GetGroupMembershipResponseCallback callback + , ArrayList groupList + , int timedInvokeTimeoutMs) { getGroupMembership(chipClusterPtr, callback, groupList, timedInvokeTimeoutMs); } - public void removeAllGroups(DefaultClusterCallback callback) { + public void removeAllGroups(DefaultClusterCallback callback + ) { removeAllGroups(chipClusterPtr, callback, null); } - public void removeAllGroups(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void removeAllGroups(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { removeAllGroups(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void removeGroup(RemoveGroupResponseCallback callback, Integer groupId) { + public void removeGroup(RemoveGroupResponseCallback callback + , Integer groupId) { removeGroup(chipClusterPtr, callback, groupId, null); } - public void removeGroup( - RemoveGroupResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { + public void removeGroup(RemoveGroupResponseCallback callback + , Integer groupId + , int timedInvokeTimeoutMs) { removeGroup(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void viewGroup(ViewGroupResponseCallback callback, Integer groupId) { + public void viewGroup(ViewGroupResponseCallback callback + , Integer groupId) { viewGroup(chipClusterPtr, callback, groupId, null); } - public void viewGroup( - ViewGroupResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { + public void viewGroup(ViewGroupResponseCallback callback + , Integer groupId + , int timedInvokeTimeoutMs) { viewGroup(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - - private native void addGroup( - long chipClusterPtr, - AddGroupResponseCallback Callback, - Integer groupId, - String groupName, - @Nullable Integer timedInvokeTimeoutMs); - - private native void addGroupIfIdentifying( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer groupId, - String groupName, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getGroupMembership( - long chipClusterPtr, - GetGroupMembershipResponseCallback Callback, - ArrayList groupList, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeAllGroups( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeGroup( - long chipClusterPtr, - RemoveGroupResponseCallback Callback, - Integer groupId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void viewGroup( - long chipClusterPtr, - ViewGroupResponseCallback Callback, - Integer groupId, - @Nullable Integer timedInvokeTimeoutMs); - + private native void addGroup(long chipClusterPtr, AddGroupResponseCallback Callback + , Integer groupId, String groupName + , @Nullable Integer timedInvokeTimeoutMs); + private native void addGroupIfIdentifying(long chipClusterPtr, DefaultClusterCallback Callback + , Integer groupId, String groupName + , @Nullable Integer timedInvokeTimeoutMs); + private native void getGroupMembership(long chipClusterPtr, GetGroupMembershipResponseCallback Callback + , ArrayList groupList + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeAllGroups(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeGroup(long chipClusterPtr, RemoveGroupResponseCallback Callback + , Integer groupId + , @Nullable Integer timedInvokeTimeoutMs); + private native void viewGroup(long chipClusterPtr, ViewGroupResponseCallback Callback + , Integer groupId + , @Nullable Integer timedInvokeTimeoutMs); public interface AddGroupResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface GetGroupMembershipResponseCallback { void onSuccess(Integer capacity, ArrayList groupList); - + void onError(Exception error); } public interface RemoveGroupResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface ViewGroupResponseCallback { void onSuccess(Integer status, Integer groupId, String groupName); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readNameSupportAttribute(IntegerAttributeCallback callback) { + public void readNameSupportAttribute( + IntegerAttributeCallback callback + ) { readNameSupportAttribute(chipClusterPtr, callback); } - public void subscribeNameSupportAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNameSupportAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNameSupportAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class IdentifyCluster extends BaseChipCluster { @@ -7037,147 +6348,144 @@ public IdentifyCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void identify(DefaultClusterCallback callback, Integer identifyTime) { + public void identify(DefaultClusterCallback callback + , Integer identifyTime) { identify(chipClusterPtr, callback, identifyTime, null); } - public void identify( - DefaultClusterCallback callback, Integer identifyTime, int timedInvokeTimeoutMs) { + public void identify(DefaultClusterCallback callback + , Integer identifyTime + , int timedInvokeTimeoutMs) { identify(chipClusterPtr, callback, identifyTime, timedInvokeTimeoutMs); } - public void identifyQuery(IdentifyQueryResponseCallback callback) { + public void identifyQuery(IdentifyQueryResponseCallback callback + ) { identifyQuery(chipClusterPtr, callback, null); } - public void identifyQuery(IdentifyQueryResponseCallback callback, int timedInvokeTimeoutMs) { - + public void identifyQuery(IdentifyQueryResponseCallback callback + + , int timedInvokeTimeoutMs) { identifyQuery(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void triggerEffect( - DefaultClusterCallback callback, Integer effectIdentifier, Integer effectVariant) { + public void triggerEffect(DefaultClusterCallback callback + , Integer effectIdentifier, Integer effectVariant) { triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, null); } - public void triggerEffect( - DefaultClusterCallback callback, - Integer effectIdentifier, - Integer effectVariant, - int timedInvokeTimeoutMs) { - triggerEffect( - chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); - } - - private native void identify( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer identifyTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void identifyQuery( - long chipClusterPtr, - IdentifyQueryResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void triggerEffect( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer effectIdentifier, - Integer effectVariant, - @Nullable Integer timedInvokeTimeoutMs); - + public void triggerEffect(DefaultClusterCallback callback + , Integer effectIdentifier, Integer effectVariant + , int timedInvokeTimeoutMs) { + triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); + } + private native void identify(long chipClusterPtr, DefaultClusterCallback Callback + , Integer identifyTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void identifyQuery(long chipClusterPtr, IdentifyQueryResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void triggerEffect(long chipClusterPtr, DefaultClusterCallback Callback + , Integer effectIdentifier, Integer effectVariant + , @Nullable Integer timedInvokeTimeoutMs); public interface IdentifyQueryResponseCallback { void onSuccess(Integer timeout); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readIdentifyTimeAttribute(IntegerAttributeCallback callback) { + public void readIdentifyTimeAttribute( + IntegerAttributeCallback callback + ) { readIdentifyTimeAttribute(chipClusterPtr, callback); } - public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value) { writeIdentifyTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeIdentifyTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeIdentifyTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeIdentifyTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeIdentifyTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readIdentifyTypeAttribute(IntegerAttributeCallback callback) { + public void readIdentifyTypeAttribute( + IntegerAttributeCallback callback + ) { readIdentifyTypeAttribute(chipClusterPtr, callback); } - public void subscribeIdentifyTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeIdentifyTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readIdentifyTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeIdentifyTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeIdentifyTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readIdentifyTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeIdentifyTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readIdentifyTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeIdentifyTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeIdentifyTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readIdentifyTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeIdentifyTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class IlluminanceMeasurementCluster extends BaseChipCluster { @@ -7190,165 +6498,164 @@ public IlluminanceMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface MeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface MinMeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface MaxMeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface LightSensorTypeAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface LightSensorTypeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute(MeasuredValueAttributeCallback callback) { + public void readMeasuredValueAttribute( + MeasuredValueAttributeCallback callback + ) { readMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMeasuredValueAttribute( - MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { + MeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute(MinMeasuredValueAttributeCallback callback) { + public void readMinMeasuredValueAttribute( + MinMeasuredValueAttributeCallback callback + ) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMinMeasuredValueAttribute( - MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { + MinMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute(MaxMeasuredValueAttributeCallback callback) { + public void readMaxMeasuredValueAttribute( + MaxMeasuredValueAttributeCallback callback + ) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMaxMeasuredValueAttribute( - MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { + MaxMeasuredValueAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute(IntegerAttributeCallback callback) { + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { readToleranceAttribute(chipClusterPtr, callback); } - public void subscribeToleranceAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLightSensorTypeAttribute(LightSensorTypeAttributeCallback callback) { + public void readLightSensorTypeAttribute( + LightSensorTypeAttributeCallback callback + ) { readLightSensorTypeAttribute(chipClusterPtr, callback); } - public void subscribeLightSensorTypeAttribute( - LightSensorTypeAttributeCallback callback, int minInterval, int maxInterval) { + LightSensorTypeAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLightSensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute( - long chipClusterPtr, MeasuredValueAttributeCallback callback); - - private native void subscribeMeasuredValueAttribute( - long chipClusterPtr, - MeasuredValueAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readMinMeasuredValueAttribute( - long chipClusterPtr, MinMeasuredValueAttributeCallback callback); - - private native void subscribeMinMeasuredValueAttribute( - long chipClusterPtr, - MinMeasuredValueAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readMaxMeasuredValueAttribute( - long chipClusterPtr, MaxMeasuredValueAttributeCallback callback); - - private native void subscribeMaxMeasuredValueAttribute( - long chipClusterPtr, - MaxMeasuredValueAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLightSensorTypeAttribute( - long chipClusterPtr, LightSensorTypeAttributeCallback callback); - - private native void subscribeLightSensorTypeAttribute( - long chipClusterPtr, - LightSensorTypeAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + MeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + MinMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLightSensorTypeAttribute(long chipClusterPtr, + LightSensorTypeAttributeCallback callback + ); + private native void subscribeLightSensorTypeAttribute(long chipClusterPtr, + LightSensorTypeAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class KeypadInputCluster extends BaseChipCluster { @@ -7361,67 +6668,69 @@ public KeypadInputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void sendKeyRequest(SendKeyResponseCallback callback, Integer keyCode) { + public void sendKeyRequest(SendKeyResponseCallback callback + , Integer keyCode) { sendKeyRequest(chipClusterPtr, callback, keyCode, null); } - public void sendKeyRequest( - SendKeyResponseCallback callback, Integer keyCode, int timedInvokeTimeoutMs) { + public void sendKeyRequest(SendKeyResponseCallback callback + , Integer keyCode + , int timedInvokeTimeoutMs) { sendKeyRequest(chipClusterPtr, callback, keyCode, timedInvokeTimeoutMs); } - - private native void sendKeyRequest( - long chipClusterPtr, - SendKeyResponseCallback Callback, - Integer keyCode, - @Nullable Integer timedInvokeTimeoutMs); - + private native void sendKeyRequest(long chipClusterPtr, SendKeyResponseCallback Callback + , Integer keyCode + , @Nullable Integer timedInvokeTimeoutMs); public interface SendKeyResponseCallback { void onSuccess(Integer status); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 LevelControlCluster extends BaseChipCluster { @@ -7434,642 +6743,535 @@ public LevelControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void move( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionMask, - Integer optionOverride) { + public void move(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride) { move(chipClusterPtr, callback, moveMode, rate, optionMask, optionOverride, null); } - public void move( - DefaultClusterCallback callback, - Integer moveMode, - Integer rate, - Integer optionMask, - Integer optionOverride, - int timedInvokeTimeoutMs) { - move( - chipClusterPtr, - callback, - moveMode, - rate, - optionMask, - optionOverride, - timedInvokeTimeoutMs); - } - - public void moveToLevel( - DefaultClusterCallback callback, - Integer level, - Integer transitionTime, - Integer optionMask, - Integer optionOverride) { - moveToLevel( - chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, null); - } - - public void moveToLevel( - DefaultClusterCallback callback, - Integer level, - Integer transitionTime, - Integer optionMask, - Integer optionOverride, - int timedInvokeTimeoutMs) { - moveToLevel( - chipClusterPtr, - callback, - level, - transitionTime, - optionMask, - optionOverride, - timedInvokeTimeoutMs); - } - - public void moveToLevelWithOnOff( - DefaultClusterCallback callback, Integer level, Integer transitionTime) { - moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, null); - } - - public void moveToLevelWithOnOff( - DefaultClusterCallback callback, - Integer level, - Integer transitionTime, - int timedInvokeTimeoutMs) { - moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, timedInvokeTimeoutMs); + public void move(DefaultClusterCallback callback + , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride + , int timedInvokeTimeoutMs) { + move(chipClusterPtr, callback, moveMode, rate, optionMask, optionOverride, timedInvokeTimeoutMs); } - public void moveWithOnOff(DefaultClusterCallback callback, Integer moveMode, Integer rate) { - moveWithOnOff(chipClusterPtr, callback, moveMode, rate, null); + public void moveToLevel(DefaultClusterCallback callback + , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride) { + moveToLevel(chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, null); } - public void moveWithOnOff( - DefaultClusterCallback callback, Integer moveMode, Integer rate, int timedInvokeTimeoutMs) { - moveWithOnOff(chipClusterPtr, callback, moveMode, rate, timedInvokeTimeoutMs); + public void moveToLevel(DefaultClusterCallback callback + , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride + , int timedInvokeTimeoutMs) { + moveToLevel(chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, timedInvokeTimeoutMs); } - public void step( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionMask, - Integer optionOverride) { - step( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionMask, - optionOverride, - null); - } - - public void step( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionMask, - Integer optionOverride, - int timedInvokeTimeoutMs) { - step( - chipClusterPtr, - callback, - stepMode, - stepSize, - transitionTime, - optionMask, - optionOverride, - timedInvokeTimeoutMs); - } - - public void stepWithOnOff( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime) { - stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, null); + public void moveToLevelWithOnOff(DefaultClusterCallback callback + , Integer level, Integer transitionTime) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, null); } - public void stepWithOnOff( - DefaultClusterCallback callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - int timedInvokeTimeoutMs) { - stepWithOnOff( - chipClusterPtr, callback, stepMode, stepSize, transitionTime, timedInvokeTimeoutMs); + public void moveToLevelWithOnOff(DefaultClusterCallback callback + , Integer level, Integer transitionTime + , int timedInvokeTimeoutMs) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, timedInvokeTimeoutMs); } - public void stop(DefaultClusterCallback callback, Integer optionMask, Integer optionOverride) { - stop(chipClusterPtr, callback, optionMask, optionOverride, null); + public void moveWithOnOff(DefaultClusterCallback callback + , Integer moveMode, Integer rate) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, null); } - public void stop( - DefaultClusterCallback callback, - Integer optionMask, - Integer optionOverride, - int timedInvokeTimeoutMs) { - stop(chipClusterPtr, callback, optionMask, optionOverride, timedInvokeTimeoutMs); + public void moveWithOnOff(DefaultClusterCallback callback + , Integer moveMode, Integer rate + , int timedInvokeTimeoutMs) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, timedInvokeTimeoutMs); } - public void stopWithOnOff(DefaultClusterCallback callback) { - stopWithOnOff(chipClusterPtr, callback, null); + public void step(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride) { + step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionMask, optionOverride, null); } - public void stopWithOnOff(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); + public void step(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride + , int timedInvokeTimeoutMs) { + step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionMask, optionOverride, timedInvokeTimeoutMs); } - private native void move( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - Integer optionMask, - Integer optionOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToLevel( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer level, - Integer transitionTime, - Integer optionMask, - Integer optionOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveToLevelWithOnOff( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer level, - Integer transitionTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void moveWithOnOff( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer moveMode, - Integer rate, - @Nullable Integer timedInvokeTimeoutMs); - - private native void step( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - Integer optionMask, - Integer optionOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stepWithOnOff( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer stepMode, - Integer stepSize, - Integer transitionTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stop( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer optionMask, - Integer optionOverride, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopWithOnOff( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface OnLevelAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stepWithOnOff(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime) { + stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, null); } - public interface OnTransitionTimeAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stepWithOnOff(DefaultClusterCallback callback + , Integer stepMode, Integer stepSize, Integer transitionTime + , int timedInvokeTimeoutMs) { + stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, timedInvokeTimeoutMs); } - public interface OffTransitionTimeAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stop(DefaultClusterCallback callback + , Integer optionMask, Integer optionOverride) { + stop(chipClusterPtr, callback, optionMask, optionOverride, null); } - public interface DefaultMoveRateAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stop(DefaultClusterCallback callback + , Integer optionMask, Integer optionOverride + , int timedInvokeTimeoutMs) { + stop(chipClusterPtr, callback, optionMask, optionOverride, timedInvokeTimeoutMs); } - public interface StartUpCurrentLevelAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stopWithOnOff(DefaultClusterCallback callback + ) { + stopWithOnOff(chipClusterPtr, callback, null); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void stopWithOnOff(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void move(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToLevel(long chipClusterPtr, DefaultClusterCallback Callback + , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveToLevelWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer level, Integer transitionTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void moveWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer moveMode, Integer rate + , @Nullable Integer timedInvokeTimeoutMs); + private native void step(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stepWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer stepMode, Integer stepSize, Integer transitionTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void stop(long chipClusterPtr, DefaultClusterCallback Callback + , Integer optionMask, Integer optionOverride + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface OnLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface OnTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface OffTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface DefaultMoveRateAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface StartUpCurrentLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readCurrentLevelAttribute(IntegerAttributeCallback callback) { + public void readCurrentLevelAttribute( + IntegerAttributeCallback callback + ) { readCurrentLevelAttribute(chipClusterPtr, callback); } - public void subscribeCurrentLevelAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRemainingTimeAttribute(IntegerAttributeCallback callback) { + public void readRemainingTimeAttribute( + IntegerAttributeCallback callback + ) { readRemainingTimeAttribute(chipClusterPtr, callback); } - public void subscribeRemainingTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinLevelAttribute(IntegerAttributeCallback callback) { + public void readMinLevelAttribute( + IntegerAttributeCallback callback + ) { readMinLevelAttribute(chipClusterPtr, callback); } - public void subscribeMinLevelAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxLevelAttribute(IntegerAttributeCallback callback) { + public void readMaxLevelAttribute( + IntegerAttributeCallback callback + ) { readMaxLevelAttribute(chipClusterPtr, callback); } - public void subscribeMaxLevelAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentFrequencyAttribute(IntegerAttributeCallback callback) { + public void readCurrentFrequencyAttribute( + IntegerAttributeCallback callback + ) { readCurrentFrequencyAttribute(chipClusterPtr, callback); } - public void subscribeCurrentFrequencyAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinFrequencyAttribute(IntegerAttributeCallback callback) { + public void readMinFrequencyAttribute( + IntegerAttributeCallback callback + ) { readMinFrequencyAttribute(chipClusterPtr, callback); } - public void subscribeMinFrequencyAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxFrequencyAttribute(IntegerAttributeCallback callback) { + public void readMaxFrequencyAttribute( + IntegerAttributeCallback callback + ) { readMaxFrequencyAttribute(chipClusterPtr, callback); } - public void subscribeMaxFrequencyAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOptionsAttribute(IntegerAttributeCallback callback) { + public void readOptionsAttribute( + IntegerAttributeCallback callback + ) { readOptionsAttribute(chipClusterPtr, callback); } - public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value) { writeOptionsAttribute(chipClusterPtr, callback, value, null); } - public void writeOptionsAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOptionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnOffTransitionTimeAttribute(IntegerAttributeCallback callback) { + public void readOnOffTransitionTimeAttribute( + IntegerAttributeCallback callback + ) { readOnOffTransitionTimeAttribute(chipClusterPtr, callback); } - public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnOffTransitionTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOnOffTransitionTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOnOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnLevelAttribute(OnLevelAttributeCallback callback) { + public void readOnLevelAttribute( + OnLevelAttributeCallback callback + ) { readOnLevelAttribute(chipClusterPtr, callback); } - public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value) { writeOnLevelAttribute(chipClusterPtr, callback, value, null); } - public void writeOnLevelAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOnLevelAttribute( - OnLevelAttributeCallback callback, int minInterval, int maxInterval) { + OnLevelAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeOnLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnTransitionTimeAttribute(OnTransitionTimeAttributeCallback callback) { + public void readOnTransitionTimeAttribute( + OnTransitionTimeAttributeCallback callback + ) { readOnTransitionTimeAttribute(chipClusterPtr, callback); } - public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnTransitionTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOnTransitionTimeAttribute( - OnTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) { + OnTransitionTimeAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeOnTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOffTransitionTimeAttribute(OffTransitionTimeAttributeCallback callback) { + public void readOffTransitionTimeAttribute( + OffTransitionTimeAttributeCallback callback + ) { readOffTransitionTimeAttribute(chipClusterPtr, callback); } - public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOffTransitionTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOffTransitionTimeAttribute( - OffTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) { + OffTransitionTimeAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDefaultMoveRateAttribute(DefaultMoveRateAttributeCallback callback) { + public void readDefaultMoveRateAttribute( + DefaultMoveRateAttributeCallback callback + ) { readDefaultMoveRateAttribute(chipClusterPtr, callback); } - public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value) { writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, null); } - public void writeDefaultMoveRateAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeDefaultMoveRateAttribute( - DefaultMoveRateAttributeCallback callback, int minInterval, int maxInterval) { + DefaultMoveRateAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeDefaultMoveRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpCurrentLevelAttribute(StartUpCurrentLevelAttributeCallback callback) { + public void readStartUpCurrentLevelAttribute( + StartUpCurrentLevelAttributeCallback callback + ) { readStartUpCurrentLevelAttribute(chipClusterPtr, callback); } - public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpCurrentLevelAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeStartUpCurrentLevelAttribute( - StartUpCurrentLevelAttributeCallback callback, int minInterval, int maxInterval) { + StartUpCurrentLevelAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeStartUpCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRemainingTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRemainingTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxFrequencyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOptionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOptionsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOptionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOnOffTransitionTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOnOffTransitionTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOnOffTransitionTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOnLevelAttribute( - long chipClusterPtr, OnLevelAttributeCallback callback); - - private native void writeOnLevelAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOnLevelAttribute( - long chipClusterPtr, OnLevelAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOnTransitionTimeAttribute( - long chipClusterPtr, OnTransitionTimeAttributeCallback callback); - - private native void writeOnTransitionTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOnTransitionTimeAttribute( - long chipClusterPtr, - OnTransitionTimeAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOffTransitionTimeAttribute( - long chipClusterPtr, OffTransitionTimeAttributeCallback callback); - - private native void writeOffTransitionTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOffTransitionTimeAttribute( - long chipClusterPtr, - OffTransitionTimeAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readDefaultMoveRateAttribute( - long chipClusterPtr, DefaultMoveRateAttributeCallback callback); - - private native void writeDefaultMoveRateAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeDefaultMoveRateAttribute( - long chipClusterPtr, - DefaultMoveRateAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readStartUpCurrentLevelAttribute( - long chipClusterPtr, StartUpCurrentLevelAttributeCallback callback); - - private native void writeStartUpCurrentLevelAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeStartUpCurrentLevelAttribute( - long chipClusterPtr, - StartUpCurrentLevelAttributeCallback 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); - } + private native void readCurrentLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRemainingTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxFrequencyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOptionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOnOffTransitionTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOnOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnOffTransitionTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOnLevelAttribute(long chipClusterPtr, + OnLevelAttributeCallback callback + ); + + private native void writeOnLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnLevelAttribute(long chipClusterPtr, + OnLevelAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOnTransitionTimeAttribute(long chipClusterPtr, + OnTransitionTimeAttributeCallback callback + ); + + private native void writeOnTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnTransitionTimeAttribute(long chipClusterPtr, + OnTransitionTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOffTransitionTimeAttribute(long chipClusterPtr, + OffTransitionTimeAttributeCallback callback + ); + + private native void writeOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOffTransitionTimeAttribute(long chipClusterPtr, + OffTransitionTimeAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readDefaultMoveRateAttribute(long chipClusterPtr, + DefaultMoveRateAttributeCallback callback + ); + + private native void writeDefaultMoveRateAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeDefaultMoveRateAttribute(long chipClusterPtr, + DefaultMoveRateAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readStartUpCurrentLevelAttribute(long chipClusterPtr, + StartUpCurrentLevelAttributeCallback callback + ); + + private native void writeStartUpCurrentLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpCurrentLevelAttribute(long chipClusterPtr, + StartUpCurrentLevelAttributeCallback 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 LocalizationConfigurationCluster extends BaseChipCluster { public static final long CLUSTER_ID = 43L; @@ -8081,79 +7283,77 @@ public LocalizationConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SupportedLocalesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface SupportedLocalesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readActiveLocaleAttribute(CharStringAttributeCallback callback) { + public void readActiveLocaleAttribute( + CharStringAttributeCallback callback + ) { readActiveLocaleAttribute(chipClusterPtr, callback); } - public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value) { writeActiveLocaleAttribute(chipClusterPtr, callback, value, null); } - public void writeActiveLocaleAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeActiveLocaleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeActiveLocaleAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActiveLocaleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedLocalesAttribute(SupportedLocalesAttributeCallback callback) { + public void readSupportedLocalesAttribute( + SupportedLocalesAttributeCallback callback + ) { readSupportedLocalesAttribute(chipClusterPtr, callback); } - public void subscribeSupportedLocalesAttribute( - SupportedLocalesAttributeCallback callback, int minInterval, int maxInterval) { + SupportedLocalesAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeSupportedLocalesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readActiveLocaleAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeActiveLocaleAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeActiveLocaleAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSupportedLocalesAttribute( - long chipClusterPtr, SupportedLocalesAttributeCallback callback); - - private native void subscribeSupportedLocalesAttribute( - long chipClusterPtr, - SupportedLocalesAttributeCallback 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); + private native void readActiveLocaleAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeActiveLocaleAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeActiveLocaleAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedLocalesAttribute(long chipClusterPtr, + SupportedLocalesAttributeCallback callback + ); + private native void subscribeSupportedLocalesAttribute(long chipClusterPtr, + SupportedLocalesAttributeCallback 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 LowPowerCluster extends BaseChipCluster { @@ -8166,60 +7366,63 @@ public LowPowerCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void sleep(DefaultClusterCallback callback) { + public void sleep(DefaultClusterCallback callback + ) { sleep(chipClusterPtr, callback, null); } - public void sleep(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void sleep(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { sleep(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void sleep(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); - private native void sleep( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 MediaInputCluster extends BaseChipCluster { @@ -8232,146 +7435,148 @@ public MediaInputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void hideInputStatusRequest(DefaultClusterCallback callback) { + public void hideInputStatusRequest(DefaultClusterCallback callback + ) { hideInputStatusRequest(chipClusterPtr, callback, null); } - public void hideInputStatusRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void hideInputStatusRequest(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { hideInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void renameInputRequest(DefaultClusterCallback callback, Integer index, String name) { + public void renameInputRequest(DefaultClusterCallback callback + , Integer index, String name) { renameInputRequest(chipClusterPtr, callback, index, name, null); } - public void renameInputRequest( - DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) { + public void renameInputRequest(DefaultClusterCallback callback + , Integer index, String name + , int timedInvokeTimeoutMs) { renameInputRequest(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); } - public void selectInputRequest(DefaultClusterCallback callback, Integer index) { + public void selectInputRequest(DefaultClusterCallback callback + , Integer index) { selectInputRequest(chipClusterPtr, callback, index, null); } - public void selectInputRequest( - DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) { + public void selectInputRequest(DefaultClusterCallback callback + , Integer index + , int timedInvokeTimeoutMs) { selectInputRequest(chipClusterPtr, callback, index, timedInvokeTimeoutMs); } - public void showInputStatusRequest(DefaultClusterCallback callback) { + public void showInputStatusRequest(DefaultClusterCallback callback + ) { showInputStatusRequest(chipClusterPtr, callback, null); } - public void showInputStatusRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void showInputStatusRequest(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { showInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void hideInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void renameInputRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index, String name + , @Nullable Integer timedInvokeTimeoutMs); + private native void selectInputRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Integer index + , @Nullable Integer timedInvokeTimeoutMs); + private native void showInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface MediaInputListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void hideInputStatusRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void renameInputRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer index, - String name, - @Nullable Integer timedInvokeTimeoutMs); - - private native void selectInputRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer index, - @Nullable Integer timedInvokeTimeoutMs); - - private native void showInputStatusRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface MediaInputListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readMediaInputListAttribute(MediaInputListAttributeCallback callback) { + public void readMediaInputListAttribute( + MediaInputListAttributeCallback callback + ) { readMediaInputListAttribute(chipClusterPtr, callback); } - public void subscribeMediaInputListAttribute( - MediaInputListAttributeCallback callback, int minInterval, int maxInterval) { + MediaInputListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeMediaInputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentMediaInputAttribute(IntegerAttributeCallback callback) { + public void readCurrentMediaInputAttribute( + IntegerAttributeCallback callback + ) { readCurrentMediaInputAttribute(chipClusterPtr, callback); } - public void subscribeCurrentMediaInputAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentMediaInputAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMediaInputListAttribute( - long chipClusterPtr, MediaInputListAttributeCallback callback); - - private native void subscribeMediaInputListAttribute( - long chipClusterPtr, - MediaInputListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentMediaInputAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentMediaInputAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMediaInputListAttribute(long chipClusterPtr, + MediaInputListAttributeCallback callback + ); + private native void subscribeMediaInputListAttribute(long chipClusterPtr, + MediaInputListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentMediaInputAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentMediaInputAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class MediaPlaybackCluster extends BaseChipCluster { @@ -8384,304 +7589,323 @@ public MediaPlaybackCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void fastForwardRequest(PlaybackResponseCallback callback) { + public void fastForwardRequest(PlaybackResponseCallback callback + ) { fastForwardRequest(chipClusterPtr, callback, null); } - public void fastForwardRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void fastForwardRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { fastForwardRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void nextRequest(PlaybackResponseCallback callback) { + public void nextRequest(PlaybackResponseCallback callback + ) { nextRequest(chipClusterPtr, callback, null); } - public void nextRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void nextRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { nextRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void pauseRequest(PlaybackResponseCallback callback) { + public void pauseRequest(PlaybackResponseCallback callback + ) { pauseRequest(chipClusterPtr, callback, null); } - public void pauseRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void pauseRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { pauseRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void playRequest(PlaybackResponseCallback callback) { + public void playRequest(PlaybackResponseCallback callback + ) { playRequest(chipClusterPtr, callback, null); } - public void playRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void playRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { playRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void previousRequest(PlaybackResponseCallback callback) { + public void previousRequest(PlaybackResponseCallback callback + ) { previousRequest(chipClusterPtr, callback, null); } - public void previousRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void previousRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { previousRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void rewindRequest(PlaybackResponseCallback callback) { + public void rewindRequest(PlaybackResponseCallback callback + ) { rewindRequest(chipClusterPtr, callback, null); } - public void rewindRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void rewindRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { rewindRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void seekRequest(PlaybackResponseCallback callback, Long position) { + public void seekRequest(PlaybackResponseCallback callback + , Long position) { seekRequest(chipClusterPtr, callback, position, null); } - public void seekRequest( - PlaybackResponseCallback callback, Long position, int timedInvokeTimeoutMs) { + public void seekRequest(PlaybackResponseCallback callback + , Long position + , int timedInvokeTimeoutMs) { seekRequest(chipClusterPtr, callback, position, timedInvokeTimeoutMs); } - public void skipBackwardRequest( - PlaybackResponseCallback callback, Long deltaPositionMilliseconds) { + public void skipBackwardRequest(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds) { skipBackwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, null); } - public void skipBackwardRequest( - PlaybackResponseCallback callback, - Long deltaPositionMilliseconds, - int timedInvokeTimeoutMs) { - skipBackwardRequest( - chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); + public void skipBackwardRequest(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds + , int timedInvokeTimeoutMs) { + skipBackwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); } - public void skipForwardRequest( - PlaybackResponseCallback callback, Long deltaPositionMilliseconds) { + public void skipForwardRequest(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds) { skipForwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, null); } - public void skipForwardRequest( - PlaybackResponseCallback callback, - Long deltaPositionMilliseconds, - int timedInvokeTimeoutMs) { + public void skipForwardRequest(PlaybackResponseCallback callback + , Long deltaPositionMilliseconds + , int timedInvokeTimeoutMs) { skipForwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); } - public void startOverRequest(PlaybackResponseCallback callback) { + public void startOverRequest(PlaybackResponseCallback callback + ) { startOverRequest(chipClusterPtr, callback, null); } - public void startOverRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void startOverRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { startOverRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void stopRequest(PlaybackResponseCallback callback) { + public void stopRequest(PlaybackResponseCallback callback + ) { stopRequest(chipClusterPtr, callback, null); } - public void stopRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - + public void stopRequest(PlaybackResponseCallback callback + + , int timedInvokeTimeoutMs) { stopRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - - private native void fastForwardRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void nextRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void pauseRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void playRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void previousRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void rewindRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void seekRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - Long position, - @Nullable Integer timedInvokeTimeoutMs); - - private native void skipBackwardRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - Long deltaPositionMilliseconds, - @Nullable Integer timedInvokeTimeoutMs); - - private native void skipForwardRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - Long deltaPositionMilliseconds, - @Nullable Integer timedInvokeTimeoutMs); - - private native void startOverRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopRequest( - long chipClusterPtr, - PlaybackResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - + private native void fastForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void nextRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void pauseRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void playRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void previousRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void rewindRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void seekRequest(long chipClusterPtr, PlaybackResponseCallback Callback + , Long position + , @Nullable Integer timedInvokeTimeoutMs); + private native void skipBackwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback + , Long deltaPositionMilliseconds + , @Nullable Integer timedInvokeTimeoutMs); + private native void skipForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback + , Long deltaPositionMilliseconds + , @Nullable Integer timedInvokeTimeoutMs); + private native void startOverRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopRequest(long chipClusterPtr, PlaybackResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); public interface PlaybackResponseCallback { void onSuccess(Integer status); - + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readPlaybackStateAttribute(IntegerAttributeCallback callback) { + public void readPlaybackStateAttribute( + IntegerAttributeCallback callback + ) { readPlaybackStateAttribute(chipClusterPtr, callback); } - public void subscribePlaybackStateAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePlaybackStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartTimeAttribute(LongAttributeCallback callback) { + public void readStartTimeAttribute( + LongAttributeCallback callback + ) { readStartTimeAttribute(chipClusterPtr, callback); } - public void subscribeStartTimeAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStartTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDurationAttribute(LongAttributeCallback callback) { + public void readDurationAttribute( + LongAttributeCallback callback + ) { readDurationAttribute(chipClusterPtr, callback); } - public void subscribeDurationAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPlaybackSpeedAttribute(FloatAttributeCallback callback) { + public void readPlaybackSpeedAttribute( + FloatAttributeCallback callback + ) { readPlaybackSpeedAttribute(chipClusterPtr, callback); } - public void subscribePlaybackSpeedAttribute( - FloatAttributeCallback callback, int minInterval, int maxInterval) { + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePlaybackSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSeekRangeEndAttribute(LongAttributeCallback callback) { + public void readSeekRangeEndAttribute( + LongAttributeCallback callback + ) { readSeekRangeEndAttribute(chipClusterPtr, callback); } - public void subscribeSeekRangeEndAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSeekRangeEndAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSeekRangeStartAttribute(LongAttributeCallback callback) { + public void readSeekRangeStartAttribute( + LongAttributeCallback callback + ) { readSeekRangeStartAttribute(chipClusterPtr, callback); } - public void subscribeSeekRangeStartAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSeekRangeStartAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readPlaybackStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePlaybackStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStartTimeAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeStartTimeAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDurationAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeDurationAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPlaybackSpeedAttribute( - long chipClusterPtr, FloatAttributeCallback callback); - - private native void subscribePlaybackSpeedAttribute( - long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSeekRangeEndAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeSeekRangeEndAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSeekRangeStartAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeSeekRangeStartAttribute( - long chipClusterPtr, LongAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readPlaybackStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePlaybackStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeStartTimeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDurationAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeDurationAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPlaybackSpeedAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + private native void subscribePlaybackSpeedAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSeekRangeEndAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSeekRangeEndAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSeekRangeStartAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeSeekRangeStartAttribute(long chipClusterPtr, + LongAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ModeSelectCluster extends BaseChipCluster { @@ -8694,164 +7918,172 @@ public ModeSelectCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void changeToMode(DefaultClusterCallback callback, Integer newMode) { + public void changeToMode(DefaultClusterCallback callback + , Integer newMode) { changeToMode(chipClusterPtr, callback, newMode, null); } - public void changeToMode( - DefaultClusterCallback callback, Integer newMode, int timedInvokeTimeoutMs) { + public void changeToMode(DefaultClusterCallback callback + , Integer newMode + , int timedInvokeTimeoutMs) { changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs); } + private native void changeToMode(long chipClusterPtr, DefaultClusterCallback Callback + , Integer newMode + , @Nullable Integer timedInvokeTimeoutMs); - private native void changeToMode( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer newMode, - @Nullable Integer timedInvokeTimeoutMs); - - public interface SupportedModesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface SupportedModesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readCurrentModeAttribute(IntegerAttributeCallback callback) { + public void readCurrentModeAttribute( + IntegerAttributeCallback callback + ) { readCurrentModeAttribute(chipClusterPtr, callback); } - public void subscribeCurrentModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedModesAttribute(SupportedModesAttributeCallback callback) { + public void readSupportedModesAttribute( + SupportedModesAttributeCallback callback + ) { readSupportedModesAttribute(chipClusterPtr, callback); } - public void subscribeSupportedModesAttribute( - SupportedModesAttributeCallback callback, int minInterval, int maxInterval) { + SupportedModesAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnModeAttribute(IntegerAttributeCallback callback) { + public void readOnModeAttribute( + IntegerAttributeCallback callback + ) { readOnModeAttribute(chipClusterPtr, callback); } - public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) { writeOnModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOnModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpModeAttribute(IntegerAttributeCallback callback) { + public void readStartUpModeAttribute( + IntegerAttributeCallback callback + ) { readStartUpModeAttribute(chipClusterPtr, callback); } - public void subscribeStartUpModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDescriptionAttribute(CharStringAttributeCallback callback) { + public void readDescriptionAttribute( + CharStringAttributeCallback callback + ) { readDescriptionAttribute(chipClusterPtr, callback); } - public void subscribeDescriptionAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSupportedModesAttribute( - long chipClusterPtr, SupportedModesAttributeCallback callback); - - private native void subscribeSupportedModesAttribute( - long chipClusterPtr, - SupportedModesAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOnModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOnModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOnModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStartUpModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeStartUpModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDescriptionAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeDescriptionAttribute( - long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + ); + private native void subscribeSupportedModesAttribute(long chipClusterPtr, + SupportedModesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOnModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStartUpModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class NetworkCommissioningCluster extends BaseChipCluster { @@ -8864,334 +8096,312 @@ public NetworkCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addOrUpdateThreadNetwork( - NetworkConfigResponseCallback callback, byte[] operationalDataset, Long breadcrumb) { + public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback + , byte[] operationalDataset, Long breadcrumb) { addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, null); } - public void addOrUpdateThreadNetwork( - NetworkConfigResponseCallback callback, - byte[] operationalDataset, - Long breadcrumb, - int timedInvokeTimeoutMs) { - addOrUpdateThreadNetwork( - chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs); + public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback + , byte[] operationalDataset, Long breadcrumb + , int timedInvokeTimeoutMs) { + addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs); } - public void addOrUpdateWiFiNetwork( - NetworkConfigResponseCallback callback, byte[] ssid, byte[] credentials, Long breadcrumb) { + public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback + , byte[] ssid, byte[] credentials, Long breadcrumb) { addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, null); } - public void addOrUpdateWiFiNetwork( - NetworkConfigResponseCallback callback, - byte[] ssid, - byte[] credentials, - Long breadcrumb, - int timedInvokeTimeoutMs) { - addOrUpdateWiFiNetwork( - chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs); + public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback + , byte[] ssid, byte[] credentials, Long breadcrumb + , int timedInvokeTimeoutMs) { + addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs); } - public void connectNetwork( - ConnectNetworkResponseCallback callback, byte[] networkID, Long breadcrumb) { + public void connectNetwork(ConnectNetworkResponseCallback callback + , byte[] networkID, Long breadcrumb) { connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); } - public void connectNetwork( - ConnectNetworkResponseCallback callback, - byte[] networkID, - Long breadcrumb, - int timedInvokeTimeoutMs) { + public void connectNetwork(ConnectNetworkResponseCallback callback + , byte[] networkID, Long breadcrumb + , int timedInvokeTimeoutMs) { connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); } - public void removeNetwork( - NetworkConfigResponseCallback callback, byte[] networkID, Long breadcrumb) { + public void removeNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Long breadcrumb) { removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); } - public void removeNetwork( - NetworkConfigResponseCallback callback, - byte[] networkID, - Long breadcrumb, - int timedInvokeTimeoutMs) { + public void removeNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Long breadcrumb + , int timedInvokeTimeoutMs) { removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); } - public void reorderNetwork( - NetworkConfigResponseCallback callback, - byte[] networkID, - Integer networkIndex, - Long breadcrumb) { + public void reorderNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Integer networkIndex, Long breadcrumb) { reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, null); } - public void reorderNetwork( - NetworkConfigResponseCallback callback, - byte[] networkID, - Integer networkIndex, - Long breadcrumb, - int timedInvokeTimeoutMs) { - reorderNetwork( - chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs); + public void reorderNetwork(NetworkConfigResponseCallback callback + , byte[] networkID, Integer networkIndex, Long breadcrumb + , int timedInvokeTimeoutMs) { + reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs); } - public void scanNetworks(ScanNetworksResponseCallback callback, byte[] ssid, Long breadcrumb) { + public void scanNetworks(ScanNetworksResponseCallback callback + , byte[] ssid, Long breadcrumb) { scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, null); } - public void scanNetworks( - ScanNetworksResponseCallback callback, - byte[] ssid, - Long breadcrumb, - int timedInvokeTimeoutMs) { + public void scanNetworks(ScanNetworksResponseCallback callback + , byte[] ssid, Long breadcrumb + , int timedInvokeTimeoutMs) { scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, timedInvokeTimeoutMs); } - - private native void addOrUpdateThreadNetwork( - long chipClusterPtr, - NetworkConfigResponseCallback Callback, - byte[] operationalDataset, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - - private native void addOrUpdateWiFiNetwork( - long chipClusterPtr, - NetworkConfigResponseCallback Callback, - byte[] ssid, - byte[] credentials, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - - private native void connectNetwork( - long chipClusterPtr, - ConnectNetworkResponseCallback Callback, - byte[] networkID, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeNetwork( - long chipClusterPtr, - NetworkConfigResponseCallback Callback, - byte[] networkID, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - - private native void reorderNetwork( - long chipClusterPtr, - NetworkConfigResponseCallback Callback, - byte[] networkID, - Integer networkIndex, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - - private native void scanNetworks( - long chipClusterPtr, - ScanNetworksResponseCallback Callback, - byte[] ssid, - Long breadcrumb, - @Nullable Integer timedInvokeTimeoutMs); - + private native void addOrUpdateThreadNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] operationalDataset, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void addOrUpdateWiFiNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] ssid, byte[] credentials, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void connectNetwork(long chipClusterPtr, ConnectNetworkResponseCallback Callback + , byte[] networkID, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] networkID, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void reorderNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback + , byte[] networkID, Integer networkIndex, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); + private native void scanNetworks(long chipClusterPtr, ScanNetworksResponseCallback Callback + , byte[] ssid, Long breadcrumb + , @Nullable Integer timedInvokeTimeoutMs); public interface ConnectNetworkResponseCallback { void onSuccess(Integer networkingStatus, String debugText, Long errorValue); - + void onError(Exception error); } public interface NetworkConfigResponseCallback { void onSuccess(Integer networkingStatus, String debugText); - + void onError(Exception error); } public interface ScanNetworksResponseCallback { - void onSuccess( - Integer networkingStatus, - String debugText, - Optional> - wiFiScanResults, - Optional> - threadScanResults); - + void onSuccess(Integer networkingStatus, String debugText, Optional> wiFiScanResults, Optional> threadScanResults); + void onError(Exception error); } - public interface NetworksAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface NetworksAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMaxNetworksAttribute(IntegerAttributeCallback callback) { + public void readMaxNetworksAttribute( + IntegerAttributeCallback callback + ) { readMaxNetworksAttribute(chipClusterPtr, callback); } - public void subscribeMaxNetworksAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNetworksAttribute(NetworksAttributeCallback callback) { + public void readNetworksAttribute( + NetworksAttributeCallback callback + ) { readNetworksAttribute(chipClusterPtr, callback); } - public void subscribeNetworksAttribute( - NetworksAttributeCallback callback, int minInterval, int maxInterval) { + NetworksAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readScanMaxTimeSecondsAttribute(IntegerAttributeCallback callback) { + public void readScanMaxTimeSecondsAttribute( + IntegerAttributeCallback callback + ) { readScanMaxTimeSecondsAttribute(chipClusterPtr, callback); } - public void subscribeScanMaxTimeSecondsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeScanMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readConnectMaxTimeSecondsAttribute(IntegerAttributeCallback callback) { + public void readConnectMaxTimeSecondsAttribute( + IntegerAttributeCallback callback + ) { readConnectMaxTimeSecondsAttribute(chipClusterPtr, callback); } - public void subscribeConnectMaxTimeSecondsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeConnectMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInterfaceEnabledAttribute(BooleanAttributeCallback callback) { + public void readInterfaceEnabledAttribute( + BooleanAttributeCallback callback + ) { readInterfaceEnabledAttribute(chipClusterPtr, callback); } - public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value) { writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, null); } - public void writeInterfaceEnabledAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInterfaceEnabledAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInterfaceEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastNetworkingStatusAttribute(IntegerAttributeCallback callback) { + public void readLastNetworkingStatusAttribute( + IntegerAttributeCallback callback + ) { readLastNetworkingStatusAttribute(chipClusterPtr, callback); } - public void subscribeLastNetworkingStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLastNetworkingStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastNetworkIDAttribute(OctetStringAttributeCallback callback) { + public void readLastNetworkIDAttribute( + OctetStringAttributeCallback callback + ) { readLastNetworkIDAttribute(chipClusterPtr, callback); } - public void subscribeLastNetworkIDAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLastNetworkIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastConnectErrorValueAttribute(LongAttributeCallback callback) { + public void readLastConnectErrorValueAttribute( + LongAttributeCallback callback + ) { readLastConnectErrorValueAttribute(chipClusterPtr, callback); } - public void subscribeLastConnectErrorValueAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLastConnectErrorValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMaxNetworksAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxNetworksAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNetworksAttribute( - long chipClusterPtr, NetworksAttributeCallback callback); - - private native void subscribeNetworksAttribute( - long chipClusterPtr, NetworksAttributeCallback callback, int minInterval, int maxInterval); - - private native void readScanMaxTimeSecondsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeScanMaxTimeSecondsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readConnectMaxTimeSecondsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeConnectMaxTimeSecondsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInterfaceEnabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeInterfaceEnabledAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInterfaceEnabledAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLastNetworkingStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLastNetworkingStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLastNetworkIDAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void subscribeLastNetworkIDAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readLastConnectErrorValueAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeLastConnectErrorValueAttribute( - long chipClusterPtr, LongAttributeCallback 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); + private native void readMaxNetworksAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxNetworksAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNetworksAttribute(long chipClusterPtr, + NetworksAttributeCallback callback + ); + private native void subscribeNetworksAttribute(long chipClusterPtr, + NetworksAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readScanMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeScanMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readConnectMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeConnectMaxTimeSecondsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInterfaceEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeInterfaceEnabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInterfaceEnabledAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLastNetworkingStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLastNetworkingStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLastNetworkIDAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + private native void subscribeLastNetworkIDAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLastConnectErrorValueAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeLastConnectErrorValueAttribute(long chipClusterPtr, + LongAttributeCallback 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 OtaSoftwareUpdateProviderCluster extends BaseChipCluster { @@ -9204,169 +8414,103 @@ public OtaSoftwareUpdateProviderCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void applyUpdateRequest( - ApplyUpdateResponseCallback callback, byte[] updateToken, Long newVersion) { + public void applyUpdateRequest(ApplyUpdateResponseCallback callback + , byte[] updateToken, Long newVersion) { applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, null); } - public void applyUpdateRequest( - ApplyUpdateResponseCallback callback, - byte[] updateToken, - Long newVersion, - int timedInvokeTimeoutMs) { + public void applyUpdateRequest(ApplyUpdateResponseCallback callback + , byte[] updateToken, Long newVersion + , int timedInvokeTimeoutMs) { applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, timedInvokeTimeoutMs); } - public void notifyUpdateApplied( - DefaultClusterCallback callback, byte[] updateToken, Long softwareVersion) { + public void notifyUpdateApplied(DefaultClusterCallback callback + , byte[] updateToken, Long softwareVersion) { notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, null); } - public void notifyUpdateApplied( - DefaultClusterCallback callback, - byte[] updateToken, - Long softwareVersion, - int timedInvokeTimeoutMs) { - notifyUpdateApplied( - chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs); - } - - public void queryImage( - QueryImageResponseCallback callback, - Integer vendorId, - Integer productId, - Long softwareVersion, - ArrayList protocolsSupported, - Optional hardwareVersion, - Optional location, - Optional requestorCanConsent, - Optional metadataForProvider) { - queryImage( - chipClusterPtr, - callback, - vendorId, - productId, - softwareVersion, - protocolsSupported, - hardwareVersion, - location, - requestorCanConsent, - metadataForProvider, - null); - } - - public void queryImage( - QueryImageResponseCallback callback, - Integer vendorId, - Integer productId, - Long softwareVersion, - ArrayList protocolsSupported, - Optional hardwareVersion, - Optional location, - Optional requestorCanConsent, - Optional metadataForProvider, - int timedInvokeTimeoutMs) { - queryImage( - chipClusterPtr, - callback, - vendorId, - productId, - softwareVersion, - protocolsSupported, - hardwareVersion, - location, - requestorCanConsent, - metadataForProvider, - timedInvokeTimeoutMs); - } - - private native void applyUpdateRequest( - long chipClusterPtr, - ApplyUpdateResponseCallback Callback, - byte[] updateToken, - Long newVersion, - @Nullable Integer timedInvokeTimeoutMs); - - private native void notifyUpdateApplied( - long chipClusterPtr, - DefaultClusterCallback Callback, - byte[] updateToken, - Long softwareVersion, - @Nullable Integer timedInvokeTimeoutMs); - - private native void queryImage( - long chipClusterPtr, - QueryImageResponseCallback Callback, - Integer vendorId, - Integer productId, - Long softwareVersion, - ArrayList protocolsSupported, - Optional hardwareVersion, - Optional location, - Optional requestorCanConsent, - Optional metadataForProvider, - @Nullable Integer timedInvokeTimeoutMs); + public void notifyUpdateApplied(DefaultClusterCallback callback + , byte[] updateToken, Long softwareVersion + , int timedInvokeTimeoutMs) { + notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs); + } + + public void queryImage(QueryImageResponseCallback callback + , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider) { + queryImage(chipClusterPtr, callback, vendorId, productId, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, null); + } + public void queryImage(QueryImageResponseCallback callback + , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider + , int timedInvokeTimeoutMs) { + queryImage(chipClusterPtr, callback, vendorId, productId, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, timedInvokeTimeoutMs); + } + private native void applyUpdateRequest(long chipClusterPtr, ApplyUpdateResponseCallback Callback + , byte[] updateToken, Long newVersion + , @Nullable Integer timedInvokeTimeoutMs); + private native void notifyUpdateApplied(long chipClusterPtr, DefaultClusterCallback Callback + , byte[] updateToken, Long softwareVersion + , @Nullable Integer timedInvokeTimeoutMs); + private native void queryImage(long chipClusterPtr, QueryImageResponseCallback Callback + , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider + , @Nullable Integer timedInvokeTimeoutMs); public interface ApplyUpdateResponseCallback { void onSuccess(Integer action, Long delayedActionTime); - + void onError(Exception error); } public interface QueryImageResponseCallback { - void onSuccess( - Integer status, - Optional delayedActionTime, - Optional imageURI, - Optional softwareVersion, - Optional softwareVersionString, - Optional updateToken, - Optional userConsentNeeded, - Optional metadataForRequestor); - + void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor); + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); - - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 OtaSoftwareUpdateRequestorCluster extends BaseChipCluster { @@ -9379,194 +8523,158 @@ public OtaSoftwareUpdateRequestorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void announceOtaProvider( - DefaultClusterCallback callback, - Long providerNodeId, - Integer vendorId, - Integer announcementReason, - Optional metadataForNode, - Integer endpoint) { - announceOtaProvider( - chipClusterPtr, - callback, - providerNodeId, - vendorId, - announcementReason, - metadataForNode, - endpoint, - null); - } - - public void announceOtaProvider( - DefaultClusterCallback callback, - Long providerNodeId, - Integer vendorId, - Integer announcementReason, - Optional metadataForNode, - Integer endpoint, - int timedInvokeTimeoutMs) { - announceOtaProvider( - chipClusterPtr, - callback, - providerNodeId, - vendorId, - announcementReason, - metadataForNode, - endpoint, - timedInvokeTimeoutMs); - } - - private native void announceOtaProvider( - long chipClusterPtr, - DefaultClusterCallback Callback, - Long providerNodeId, - Integer vendorId, - Integer announcementReason, - Optional metadataForNode, - Integer endpoint, - @Nullable Integer timedInvokeTimeoutMs); - - public interface DefaultOtaProvidersAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void announceOtaProvider(DefaultClusterCallback callback + , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint) { + announceOtaProvider(chipClusterPtr, callback, providerNodeId, vendorId, announcementReason, metadataForNode, endpoint, null); } - public interface UpdateStateProgressAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void announceOtaProvider(DefaultClusterCallback callback + , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint + , int timedInvokeTimeoutMs) { + announceOtaProvider(chipClusterPtr, callback, providerNodeId, vendorId, announcementReason, metadataForNode, endpoint, timedInvokeTimeoutMs); } + private native void announceOtaProvider(long chipClusterPtr, DefaultClusterCallback Callback + , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint + , @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface DefaultOtaProvidersAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface UpdateStateProgressAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readDefaultOtaProvidersAttribute(DefaultOtaProvidersAttributeCallback callback) { + public void readDefaultOtaProvidersAttribute( + DefaultOtaProvidersAttributeCallback callback + ) { readDefaultOtaProvidersAttribute(chipClusterPtr, callback); } - - public void writeDefaultOtaProvidersAttribute( - DefaultClusterCallback callback, - ArrayList value) { + public void writeDefaultOtaProvidersAttribute(DefaultClusterCallback callback, ArrayList value) { writeDefaultOtaProvidersAttribute(chipClusterPtr, callback, value, null); } - public void writeDefaultOtaProvidersAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { + public void writeDefaultOtaProvidersAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeDefaultOtaProvidersAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeDefaultOtaProvidersAttribute( - DefaultOtaProvidersAttributeCallback callback, int minInterval, int maxInterval) { + DefaultOtaProvidersAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeDefaultOtaProvidersAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdatePossibleAttribute(BooleanAttributeCallback callback) { + public void readUpdatePossibleAttribute( + BooleanAttributeCallback callback + ) { readUpdatePossibleAttribute(chipClusterPtr, callback); } - public void subscribeUpdatePossibleAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeUpdatePossibleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdateStateAttribute(IntegerAttributeCallback callback) { + public void readUpdateStateAttribute( + IntegerAttributeCallback callback + ) { readUpdateStateAttribute(chipClusterPtr, callback); } - public void subscribeUpdateStateAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeUpdateStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdateStateProgressAttribute(UpdateStateProgressAttributeCallback callback) { + public void readUpdateStateProgressAttribute( + UpdateStateProgressAttributeCallback callback + ) { readUpdateStateProgressAttribute(chipClusterPtr, callback); } - public void subscribeUpdateStateProgressAttribute( - UpdateStateProgressAttributeCallback callback, int minInterval, int maxInterval) { + UpdateStateProgressAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeUpdateStateProgressAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readDefaultOtaProvidersAttribute( - long chipClusterPtr, DefaultOtaProvidersAttributeCallback callback); - - private native void writeDefaultOtaProvidersAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeDefaultOtaProvidersAttribute( - long chipClusterPtr, - DefaultOtaProvidersAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readUpdatePossibleAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeUpdatePossibleAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readUpdateStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeUpdateStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readUpdateStateProgressAttribute( - long chipClusterPtr, UpdateStateProgressAttributeCallback callback); - - private native void subscribeUpdateStateProgressAttribute( - long chipClusterPtr, - UpdateStateProgressAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readDefaultOtaProvidersAttribute(long chipClusterPtr, + DefaultOtaProvidersAttributeCallback callback + ); + + private native void writeDefaultOtaProvidersAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeDefaultOtaProvidersAttribute(long chipClusterPtr, + DefaultOtaProvidersAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readUpdatePossibleAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeUpdatePossibleAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUpdateStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeUpdateStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUpdateStateProgressAttribute(long chipClusterPtr, + UpdateStateProgressAttributeCallback callback + ); + private native void subscribeUpdateStateProgressAttribute(long chipClusterPtr, + UpdateStateProgressAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class OccupancySensingCluster extends BaseChipCluster { @@ -9579,92 +8687,106 @@ public OccupancySensingCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readOccupancyAttribute(IntegerAttributeCallback callback) { + public void readOccupancyAttribute( + IntegerAttributeCallback callback + ) { readOccupancyAttribute(chipClusterPtr, callback); } - public void subscribeOccupancyAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOccupancyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupancySensorTypeAttribute(IntegerAttributeCallback callback) { + public void readOccupancySensorTypeAttribute( + IntegerAttributeCallback callback + ) { readOccupancySensorTypeAttribute(chipClusterPtr, callback); } - public void subscribeOccupancySensorTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOccupancySensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupancySensorTypeBitmapAttribute(IntegerAttributeCallback callback) { + public void readOccupancySensorTypeBitmapAttribute( + IntegerAttributeCallback callback + ) { readOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback); } - public void subscribeOccupancySensorTypeBitmapAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeOccupancySensorTypeBitmapAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOccupancyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeOccupancyAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOccupancySensorTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeOccupancySensorTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOccupancySensorTypeBitmapAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeOccupancySensorTypeBitmapAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readOccupancyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOccupancyAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOccupancySensorTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeBitmapAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOccupancySensorTypeBitmapAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class OnOffCluster extends BaseChipCluster { @@ -9677,281 +8799,274 @@ public OnOffCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void off(DefaultClusterCallback callback) { + public void off(DefaultClusterCallback callback + ) { off(chipClusterPtr, callback, null); } - public void off(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void off(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { off(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void offWithEffect( - DefaultClusterCallback callback, Integer effectId, Integer effectVariant) { + public void offWithEffect(DefaultClusterCallback callback + , Integer effectId, Integer effectVariant) { offWithEffect(chipClusterPtr, callback, effectId, effectVariant, null); } - public void offWithEffect( - DefaultClusterCallback callback, - Integer effectId, - Integer effectVariant, - int timedInvokeTimeoutMs) { + public void offWithEffect(DefaultClusterCallback callback + , Integer effectId, Integer effectVariant + , int timedInvokeTimeoutMs) { offWithEffect(chipClusterPtr, callback, effectId, effectVariant, timedInvokeTimeoutMs); } - public void on(DefaultClusterCallback callback) { + public void on(DefaultClusterCallback callback + ) { on(chipClusterPtr, callback, null); } - public void on(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void on(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { on(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void onWithRecallGlobalScene(DefaultClusterCallback callback) { + public void onWithRecallGlobalScene(DefaultClusterCallback callback + ) { onWithRecallGlobalScene(chipClusterPtr, callback, null); } - public void onWithRecallGlobalScene(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void onWithRecallGlobalScene(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { onWithRecallGlobalScene(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void onWithTimedOff( - DefaultClusterCallback callback, - Integer onOffControl, - Integer onTime, - Integer offWaitTime) { + public void onWithTimedOff(DefaultClusterCallback callback + , Integer onOffControl, Integer onTime, Integer offWaitTime) { onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, null); } - public void onWithTimedOff( - DefaultClusterCallback callback, - Integer onOffControl, - Integer onTime, - Integer offWaitTime, - int timedInvokeTimeoutMs) { - onWithTimedOff( - chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs); + public void onWithTimedOff(DefaultClusterCallback callback + , Integer onOffControl, Integer onTime, Integer offWaitTime + , int timedInvokeTimeoutMs) { + onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs); } - public void toggle(DefaultClusterCallback callback) { + public void toggle(DefaultClusterCallback callback + ) { toggle(chipClusterPtr, callback, null); } - public void toggle(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void toggle(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { toggle(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void off(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void offWithEffect(long chipClusterPtr, DefaultClusterCallback Callback + , Integer effectId, Integer effectVariant + , @Nullable Integer timedInvokeTimeoutMs); + private native void on(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void onWithRecallGlobalScene(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void onWithTimedOff(long chipClusterPtr, DefaultClusterCallback Callback + , Integer onOffControl, Integer onTime, Integer offWaitTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void toggle(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void off( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void offWithEffect( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer effectId, - Integer effectVariant, - @Nullable Integer timedInvokeTimeoutMs); - - private native void on( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void onWithRecallGlobalScene( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void onWithTimedOff( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer onOffControl, - Integer onTime, - Integer offWaitTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void toggle( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readOnOffAttribute(BooleanAttributeCallback callback) { + public void readOnOffAttribute( + BooleanAttributeCallback callback + ) { readOnOffAttribute(chipClusterPtr, callback); } - public void subscribeOnOffAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGlobalSceneControlAttribute(BooleanAttributeCallback callback) { + public void readGlobalSceneControlAttribute( + BooleanAttributeCallback callback + ) { readGlobalSceneControlAttribute(chipClusterPtr, callback); } - public void subscribeGlobalSceneControlAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeGlobalSceneControlAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnTimeAttribute(IntegerAttributeCallback callback) { + public void readOnTimeAttribute( + IntegerAttributeCallback callback + ) { readOnTimeAttribute(chipClusterPtr, callback); } - public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOnTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOnTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOffWaitTimeAttribute(IntegerAttributeCallback callback) { + public void readOffWaitTimeAttribute( + IntegerAttributeCallback callback + ) { readOffWaitTimeAttribute(chipClusterPtr, callback); } - public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOffWaitTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOffWaitTimeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOffWaitTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOffWaitTimeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOffWaitTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpOnOffAttribute(IntegerAttributeCallback callback) { + public void readStartUpOnOffAttribute( + IntegerAttributeCallback callback + ) { readStartUpOnOffAttribute(chipClusterPtr, callback); } - public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpOnOffAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpOnOffAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeStartUpOnOffAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeStartUpOnOffAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStartUpOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOnOffAttribute(long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeOnOffAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readGlobalSceneControlAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeGlobalSceneControlAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOnTimeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOnTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOnTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOffWaitTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOffWaitTimeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOffWaitTimeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStartUpOnOffAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeStartUpOnOffAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeStartUpOnOffAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readOnOffAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeOnOffAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGlobalSceneControlAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeGlobalSceneControlAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOnTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOnTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOnTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOffWaitTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOffWaitTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOffWaitTimeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartUpOnOffAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeStartUpOnOffAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeStartUpOnOffAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 OnOffSwitchConfigurationCluster extends BaseChipCluster { @@ -9964,91 +9079,96 @@ public OnOffSwitchConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readSwitchTypeAttribute(IntegerAttributeCallback callback) { + public void readSwitchTypeAttribute( + IntegerAttributeCallback callback + ) { readSwitchTypeAttribute(chipClusterPtr, callback); } - public void subscribeSwitchTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSwitchTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSwitchActionsAttribute(IntegerAttributeCallback callback) { + public void readSwitchActionsAttribute( + IntegerAttributeCallback callback + ) { readSwitchActionsAttribute(chipClusterPtr, callback); } - public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value) { writeSwitchActionsAttribute(chipClusterPtr, callback, value, null); } - public void writeSwitchActionsAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSwitchActionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeSwitchActionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSwitchActionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSwitchTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSwitchTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSwitchActionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeSwitchActionsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeSwitchActionsAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readSwitchTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSwitchTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSwitchActionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeSwitchActionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSwitchActionsAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class OperationalCredentialsCluster extends BaseChipCluster { @@ -10061,378 +9181,333 @@ public OperationalCredentialsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addNOC( - NOCResponseCallback callback, - byte[] NOCValue, - Optional ICACValue, - byte[] IPKValue, - Long caseAdminNode, - Integer adminVendorId) { - addNOC( - chipClusterPtr, - callback, - NOCValue, - ICACValue, - IPKValue, - caseAdminNode, - adminVendorId, - null); - } - - public void addNOC( - NOCResponseCallback callback, - byte[] NOCValue, - Optional ICACValue, - byte[] IPKValue, - Long caseAdminNode, - Integer adminVendorId, - int timedInvokeTimeoutMs) { - addNOC( - chipClusterPtr, - callback, - NOCValue, - ICACValue, - IPKValue, - caseAdminNode, - adminVendorId, - timedInvokeTimeoutMs); - } - - public void addTrustedRootCertificate(DefaultClusterCallback callback, byte[] rootCertificate) { + public void addNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId) { + addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminNode, adminVendorId, null); + } + + public void addNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId + , int timedInvokeTimeoutMs) { + addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminNode, adminVendorId, timedInvokeTimeoutMs); + } + + public void addTrustedRootCertificate(DefaultClusterCallback callback + , byte[] rootCertificate) { addTrustedRootCertificate(chipClusterPtr, callback, rootCertificate, null); } - public void addTrustedRootCertificate( - DefaultClusterCallback callback, byte[] rootCertificate, int timedInvokeTimeoutMs) { + public void addTrustedRootCertificate(DefaultClusterCallback callback + , byte[] rootCertificate + , int timedInvokeTimeoutMs) { addTrustedRootCertificate(chipClusterPtr, callback, rootCertificate, timedInvokeTimeoutMs); } - public void attestationRequest(AttestationResponseCallback callback, byte[] attestationNonce) { + public void attestationRequest(AttestationResponseCallback callback + , byte[] attestationNonce) { attestationRequest(chipClusterPtr, callback, attestationNonce, null); } - public void attestationRequest( - AttestationResponseCallback callback, byte[] attestationNonce, int timedInvokeTimeoutMs) { + public void attestationRequest(AttestationResponseCallback callback + , byte[] attestationNonce + , int timedInvokeTimeoutMs) { attestationRequest(chipClusterPtr, callback, attestationNonce, timedInvokeTimeoutMs); } - public void certificateChainRequest( - CertificateChainResponseCallback callback, Integer certificateType) { + public void certificateChainRequest(CertificateChainResponseCallback callback + , Integer certificateType) { certificateChainRequest(chipClusterPtr, callback, certificateType, null); } - public void certificateChainRequest( - CertificateChainResponseCallback callback, - Integer certificateType, - int timedInvokeTimeoutMs) { + public void certificateChainRequest(CertificateChainResponseCallback callback + , Integer certificateType + , int timedInvokeTimeoutMs) { certificateChainRequest(chipClusterPtr, callback, certificateType, timedInvokeTimeoutMs); } - public void opCSRRequest(OpCSRResponseCallback callback, byte[] CSRNonce) { + public void opCSRRequest(OpCSRResponseCallback callback + , byte[] CSRNonce) { opCSRRequest(chipClusterPtr, callback, CSRNonce, null); } - public void opCSRRequest( - OpCSRResponseCallback callback, byte[] CSRNonce, int timedInvokeTimeoutMs) { + public void opCSRRequest(OpCSRResponseCallback callback + , byte[] CSRNonce + , int timedInvokeTimeoutMs) { opCSRRequest(chipClusterPtr, callback, CSRNonce, timedInvokeTimeoutMs); } - public void removeFabric(NOCResponseCallback callback, Integer fabricIndex) { + public void removeFabric(NOCResponseCallback callback + , Integer fabricIndex) { removeFabric(chipClusterPtr, callback, fabricIndex, null); } - public void removeFabric( - NOCResponseCallback callback, Integer fabricIndex, int timedInvokeTimeoutMs) { + public void removeFabric(NOCResponseCallback callback + , Integer fabricIndex + , int timedInvokeTimeoutMs) { removeFabric(chipClusterPtr, callback, fabricIndex, timedInvokeTimeoutMs); } - public void removeTrustedRootCertificate( - DefaultClusterCallback callback, byte[] trustedRootIdentifier) { + public void removeTrustedRootCertificate(DefaultClusterCallback callback + , byte[] trustedRootIdentifier) { removeTrustedRootCertificate(chipClusterPtr, callback, trustedRootIdentifier, null); } - public void removeTrustedRootCertificate( - DefaultClusterCallback callback, byte[] trustedRootIdentifier, int timedInvokeTimeoutMs) { - removeTrustedRootCertificate( - chipClusterPtr, callback, trustedRootIdentifier, timedInvokeTimeoutMs); + public void removeTrustedRootCertificate(DefaultClusterCallback callback + , byte[] trustedRootIdentifier + , int timedInvokeTimeoutMs) { + removeTrustedRootCertificate(chipClusterPtr, callback, trustedRootIdentifier, timedInvokeTimeoutMs); } - public void updateFabricLabel(NOCResponseCallback callback, String label) { + public void updateFabricLabel(NOCResponseCallback callback + , String label) { updateFabricLabel(chipClusterPtr, callback, label, null); } - public void updateFabricLabel( - NOCResponseCallback callback, String label, int timedInvokeTimeoutMs) { + public void updateFabricLabel(NOCResponseCallback callback + , String label + , int timedInvokeTimeoutMs) { updateFabricLabel(chipClusterPtr, callback, label, timedInvokeTimeoutMs); } - public void updateNOC( - NOCResponseCallback callback, byte[] NOCValue, Optional ICACValue) { + public void updateNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue) { updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, null); } - public void updateNOC( - NOCResponseCallback callback, - byte[] NOCValue, - Optional ICACValue, - int timedInvokeTimeoutMs) { + public void updateNOC(NOCResponseCallback callback + , byte[] NOCValue, Optional ICACValue + , int timedInvokeTimeoutMs) { updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, timedInvokeTimeoutMs); } - - private native void addNOC( - long chipClusterPtr, - NOCResponseCallback Callback, - byte[] NOCValue, - Optional ICACValue, - byte[] IPKValue, - Long caseAdminNode, - Integer adminVendorId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void addTrustedRootCertificate( - long chipClusterPtr, - DefaultClusterCallback Callback, - byte[] rootCertificate, - @Nullable Integer timedInvokeTimeoutMs); - - private native void attestationRequest( - long chipClusterPtr, - AttestationResponseCallback Callback, - byte[] attestationNonce, - @Nullable Integer timedInvokeTimeoutMs); - - private native void certificateChainRequest( - long chipClusterPtr, - CertificateChainResponseCallback Callback, - Integer certificateType, - @Nullable Integer timedInvokeTimeoutMs); - - private native void opCSRRequest( - long chipClusterPtr, - OpCSRResponseCallback Callback, - byte[] CSRNonce, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeFabric( - long chipClusterPtr, - NOCResponseCallback Callback, - Integer fabricIndex, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeTrustedRootCertificate( - long chipClusterPtr, - DefaultClusterCallback Callback, - byte[] trustedRootIdentifier, - @Nullable Integer timedInvokeTimeoutMs); - - private native void updateFabricLabel( - long chipClusterPtr, - NOCResponseCallback Callback, - String label, - @Nullable Integer timedInvokeTimeoutMs); - - private native void updateNOC( - long chipClusterPtr, - NOCResponseCallback Callback, - byte[] NOCValue, - Optional ICACValue, - @Nullable Integer timedInvokeTimeoutMs); - + private native void addNOC(long chipClusterPtr, NOCResponseCallback Callback + , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId + , @Nullable Integer timedInvokeTimeoutMs); + private native void addTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback Callback + , byte[] rootCertificate + , @Nullable Integer timedInvokeTimeoutMs); + private native void attestationRequest(long chipClusterPtr, AttestationResponseCallback Callback + , byte[] attestationNonce + , @Nullable Integer timedInvokeTimeoutMs); + private native void certificateChainRequest(long chipClusterPtr, CertificateChainResponseCallback Callback + , Integer certificateType + , @Nullable Integer timedInvokeTimeoutMs); + private native void opCSRRequest(long chipClusterPtr, OpCSRResponseCallback Callback + , byte[] CSRNonce + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeFabric(long chipClusterPtr, NOCResponseCallback Callback + , Integer fabricIndex + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback Callback + , byte[] trustedRootIdentifier + , @Nullable Integer timedInvokeTimeoutMs); + private native void updateFabricLabel(long chipClusterPtr, NOCResponseCallback Callback + , String label + , @Nullable Integer timedInvokeTimeoutMs); + private native void updateNOC(long chipClusterPtr, NOCResponseCallback Callback + , byte[] NOCValue, Optional ICACValue + , @Nullable Integer timedInvokeTimeoutMs); public interface AttestationResponseCallback { void onSuccess(byte[] attestationElements, byte[] signature); - + void onError(Exception error); } public interface CertificateChainResponseCallback { void onSuccess(byte[] certificate); - + void onError(Exception error); } public interface NOCResponseCallback { void onSuccess(Integer statusCode, Integer fabricIndex, String debugText); - + void onError(Exception error); } public interface OpCSRResponseCallback { void onSuccess(byte[] NOCSRElements, byte[] attestationSignature); - + void onError(Exception error); } - public interface NOCsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface FabricsListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface TrustedRootCertificatesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentFabricIndexAttributeCallback { - void onSuccess(Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface NOCsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface FabricsListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface TrustedRootCertificatesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentFabricIndexAttributeCallback { + void onSuccess( Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readNOCsAttribute(NOCsAttributeCallback callback) { + public void readNOCsAttribute( + NOCsAttributeCallback callback + ) { readNOCsAttribute(chipClusterPtr, callback); } - public void subscribeNOCsAttribute( - NOCsAttributeCallback callback, int minInterval, int maxInterval) { + NOCsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNOCsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFabricsListAttribute(FabricsListAttributeCallback callback) { + public void readFabricsListAttribute( + FabricsListAttributeCallback callback + ) { readFabricsListAttribute(chipClusterPtr, callback); } - public void subscribeFabricsListAttribute( - FabricsListAttributeCallback callback, int minInterval, int maxInterval) { + FabricsListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeFabricsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedFabricsAttribute(IntegerAttributeCallback callback) { + public void readSupportedFabricsAttribute( + IntegerAttributeCallback callback + ) { readSupportedFabricsAttribute(chipClusterPtr, callback); } - public void subscribeSupportedFabricsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSupportedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCommissionedFabricsAttribute(IntegerAttributeCallback callback) { + public void readCommissionedFabricsAttribute( + IntegerAttributeCallback callback + ) { readCommissionedFabricsAttribute(chipClusterPtr, callback); } - public void subscribeCommissionedFabricsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCommissionedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTrustedRootCertificatesAttribute( - TrustedRootCertificatesAttributeCallback callback) { + TrustedRootCertificatesAttributeCallback callback + ) { readTrustedRootCertificatesAttribute(chipClusterPtr, callback); } - public void subscribeTrustedRootCertificatesAttribute( - TrustedRootCertificatesAttributeCallback callback, int minInterval, int maxInterval) { + TrustedRootCertificatesAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeTrustedRootCertificatesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentFabricIndexAttribute(CurrentFabricIndexAttributeCallback callback) { + public void readCurrentFabricIndexAttribute( + CurrentFabricIndexAttributeCallback callback + ) { readCurrentFabricIndexAttribute(chipClusterPtr, callback); } - public void subscribeCurrentFabricIndexAttribute( - CurrentFabricIndexAttributeCallback callback, int minInterval, int maxInterval) { + CurrentFabricIndexAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeCurrentFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNOCsAttribute(long chipClusterPtr, NOCsAttributeCallback callback); - - private native void subscribeNOCsAttribute( - long chipClusterPtr, NOCsAttributeCallback callback, int minInterval, int maxInterval); - - private native void readFabricsListAttribute( - long chipClusterPtr, FabricsListAttributeCallback callback); - - private native void subscribeFabricsListAttribute( - long chipClusterPtr, - FabricsListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSupportedFabricsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSupportedFabricsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCommissionedFabricsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCommissionedFabricsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTrustedRootCertificatesAttribute( - long chipClusterPtr, TrustedRootCertificatesAttributeCallback callback); - - private native void subscribeTrustedRootCertificatesAttribute( - long chipClusterPtr, - TrustedRootCertificatesAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentFabricIndexAttribute( - long chipClusterPtr, CurrentFabricIndexAttributeCallback callback); - - private native void subscribeCurrentFabricIndexAttribute( - long chipClusterPtr, - CurrentFabricIndexAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readNOCsAttribute(long chipClusterPtr, + NOCsAttributeCallback callback + ); + private native void subscribeNOCsAttribute(long chipClusterPtr, + NOCsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readFabricsListAttribute(long chipClusterPtr, + FabricsListAttributeCallback callback + ); + private native void subscribeFabricsListAttribute(long chipClusterPtr, + FabricsListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readSupportedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSupportedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCommissionedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCommissionedFabricsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTrustedRootCertificatesAttribute(long chipClusterPtr, + TrustedRootCertificatesAttributeCallback callback + ); + private native void subscribeTrustedRootCertificatesAttribute(long chipClusterPtr, + TrustedRootCertificatesAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentFabricIndexAttribute(long chipClusterPtr, + CurrentFabricIndexAttributeCallback callback + ); + private native void subscribeCurrentFabricIndexAttribute(long chipClusterPtr, + CurrentFabricIndexAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class PowerSourceCluster extends BaseChipCluster { @@ -10445,208 +9520,244 @@ public PowerSourceCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface ActiveBatteryFaultsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface ActiveBatteryFaultsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readStatusAttribute(IntegerAttributeCallback callback) { + public void readStatusAttribute( + IntegerAttributeCallback callback + ) { readStatusAttribute(chipClusterPtr, callback); } - public void subscribeStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOrderAttribute(IntegerAttributeCallback callback) { + public void readOrderAttribute( + IntegerAttributeCallback callback + ) { readOrderAttribute(chipClusterPtr, callback); } - public void subscribeOrderAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOrderAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDescriptionAttribute(CharStringAttributeCallback callback) { + public void readDescriptionAttribute( + CharStringAttributeCallback callback + ) { readDescriptionAttribute(chipClusterPtr, callback); } - public void subscribeDescriptionAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryVoltageAttribute(LongAttributeCallback callback) { + public void readBatteryVoltageAttribute( + LongAttributeCallback callback + ) { readBatteryVoltageAttribute(chipClusterPtr, callback); } - public void subscribeBatteryVoltageAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBatteryVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryPercentRemainingAttribute(IntegerAttributeCallback callback) { + public void readBatteryPercentRemainingAttribute( + IntegerAttributeCallback callback + ) { readBatteryPercentRemainingAttribute(chipClusterPtr, callback); } - public void subscribeBatteryPercentRemainingAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBatteryPercentRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryTimeRemainingAttribute(LongAttributeCallback callback) { + public void readBatteryTimeRemainingAttribute( + LongAttributeCallback callback + ) { readBatteryTimeRemainingAttribute(chipClusterPtr, callback); } - public void subscribeBatteryTimeRemainingAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBatteryTimeRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryChargeLevelAttribute(IntegerAttributeCallback callback) { + public void readBatteryChargeLevelAttribute( + IntegerAttributeCallback callback + ) { readBatteryChargeLevelAttribute(chipClusterPtr, callback); } - public void subscribeBatteryChargeLevelAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBatteryChargeLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveBatteryFaultsAttribute(ActiveBatteryFaultsAttributeCallback callback) { + public void readActiveBatteryFaultsAttribute( + ActiveBatteryFaultsAttributeCallback callback + ) { readActiveBatteryFaultsAttribute(chipClusterPtr, callback); } - public void subscribeActiveBatteryFaultsAttribute( - ActiveBatteryFaultsAttributeCallback callback, int minInterval, int maxInterval) { + ActiveBatteryFaultsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeActiveBatteryFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryChargeStateAttribute(IntegerAttributeCallback callback) { + public void readBatteryChargeStateAttribute( + IntegerAttributeCallback callback + ) { readBatteryChargeStateAttribute(chipClusterPtr, callback); } - public void subscribeBatteryChargeStateAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBatteryChargeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readStatusAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOrderAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeOrderAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDescriptionAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeDescriptionAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readBatteryVoltageAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeBatteryVoltageAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBatteryPercentRemainingAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBatteryPercentRemainingAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBatteryTimeRemainingAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeBatteryTimeRemainingAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBatteryChargeLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBatteryChargeLevelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActiveBatteryFaultsAttribute( - long chipClusterPtr, ActiveBatteryFaultsAttributeCallback callback); - - private native void subscribeActiveBatteryFaultsAttribute( - long chipClusterPtr, - ActiveBatteryFaultsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readBatteryChargeStateAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBatteryChargeStateAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOrderAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOrderAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeDescriptionAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatteryVoltageAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeBatteryVoltageAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatteryPercentRemainingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatteryPercentRemainingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatteryTimeRemainingAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeBatteryTimeRemainingAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBatteryChargeLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatteryChargeLevelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveBatteryFaultsAttribute(long chipClusterPtr, + ActiveBatteryFaultsAttributeCallback callback + ); + private native void subscribeActiveBatteryFaultsAttribute(long chipClusterPtr, + ActiveBatteryFaultsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readBatteryChargeStateAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBatteryChargeStateAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 PowerSourceConfigurationCluster extends BaseChipCluster { @@ -10659,69 +9770,73 @@ public PowerSourceConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SourcesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface SourcesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readSourcesAttribute(SourcesAttributeCallback callback) { + public void readSourcesAttribute( + SourcesAttributeCallback callback + ) { readSourcesAttribute(chipClusterPtr, callback); } - public void subscribeSourcesAttribute( - SourcesAttributeCallback callback, int minInterval, int maxInterval) { + SourcesAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeSourcesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSourcesAttribute( - long chipClusterPtr, SourcesAttributeCallback callback); - - private native void subscribeSourcesAttribute( - long chipClusterPtr, SourcesAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readSourcesAttribute(long chipClusterPtr, + SourcesAttributeCallback callback + ); + private native void subscribeSourcesAttribute(long chipClusterPtr, + SourcesAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class PressureMeasurementCluster extends BaseChipCluster { @@ -10734,91 +9849,106 @@ public PressureMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMinMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMaxMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class PumpConfigurationAndControlCluster extends BaseChipCluster { @@ -10831,614 +9961,701 @@ public PumpConfigurationAndControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LifetimeRunningHoursAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface LifetimeEnergyConsumedAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface LifetimeRunningHoursAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface LifetimeEnergyConsumedAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMaxPressureAttribute(IntegerAttributeCallback callback) { + public void readMaxPressureAttribute( + IntegerAttributeCallback callback + ) { readMaxPressureAttribute(chipClusterPtr, callback); } - public void subscribeMaxPressureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxSpeedAttribute(IntegerAttributeCallback callback) { + public void readMaxSpeedAttribute( + IntegerAttributeCallback callback + ) { readMaxSpeedAttribute(chipClusterPtr, callback); } - public void subscribeMaxSpeedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxFlowAttribute(IntegerAttributeCallback callback) { + public void readMaxFlowAttribute( + IntegerAttributeCallback callback + ) { readMaxFlowAttribute(chipClusterPtr, callback); } - public void subscribeMaxFlowAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstPressureAttribute(IntegerAttributeCallback callback) { + public void readMinConstPressureAttribute( + IntegerAttributeCallback callback + ) { readMinConstPressureAttribute(chipClusterPtr, callback); } - public void subscribeMinConstPressureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstPressureAttribute(IntegerAttributeCallback callback) { + public void readMaxConstPressureAttribute( + IntegerAttributeCallback callback + ) { readMaxConstPressureAttribute(chipClusterPtr, callback); } - public void subscribeMaxConstPressureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinCompPressureAttribute(IntegerAttributeCallback callback) { + public void readMinCompPressureAttribute( + IntegerAttributeCallback callback + ) { readMinCompPressureAttribute(chipClusterPtr, callback); } - public void subscribeMinCompPressureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxCompPressureAttribute(IntegerAttributeCallback callback) { + public void readMaxCompPressureAttribute( + IntegerAttributeCallback callback + ) { readMaxCompPressureAttribute(chipClusterPtr, callback); } - public void subscribeMaxCompPressureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstSpeedAttribute(IntegerAttributeCallback callback) { + public void readMinConstSpeedAttribute( + IntegerAttributeCallback callback + ) { readMinConstSpeedAttribute(chipClusterPtr, callback); } - public void subscribeMinConstSpeedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstSpeedAttribute(IntegerAttributeCallback callback) { + public void readMaxConstSpeedAttribute( + IntegerAttributeCallback callback + ) { readMaxConstSpeedAttribute(chipClusterPtr, callback); } - public void subscribeMaxConstSpeedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstFlowAttribute(IntegerAttributeCallback callback) { + public void readMinConstFlowAttribute( + IntegerAttributeCallback callback + ) { readMinConstFlowAttribute(chipClusterPtr, callback); } - public void subscribeMinConstFlowAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstFlowAttribute(IntegerAttributeCallback callback) { + public void readMaxConstFlowAttribute( + IntegerAttributeCallback callback + ) { readMaxConstFlowAttribute(chipClusterPtr, callback); } - public void subscribeMaxConstFlowAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstTempAttribute(IntegerAttributeCallback callback) { + public void readMinConstTempAttribute( + IntegerAttributeCallback callback + ) { readMinConstTempAttribute(chipClusterPtr, callback); } - public void subscribeMinConstTempAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstTempAttribute(IntegerAttributeCallback callback) { + public void readMaxConstTempAttribute( + IntegerAttributeCallback callback + ) { readMaxConstTempAttribute(chipClusterPtr, callback); } - public void subscribeMaxConstTempAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPumpStatusAttribute(IntegerAttributeCallback callback) { + public void readPumpStatusAttribute( + IntegerAttributeCallback callback + ) { readPumpStatusAttribute(chipClusterPtr, callback); } - public void subscribePumpStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePumpStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEffectiveOperationModeAttribute(IntegerAttributeCallback callback) { + public void readEffectiveOperationModeAttribute( + IntegerAttributeCallback callback + ) { readEffectiveOperationModeAttribute(chipClusterPtr, callback); } - public void subscribeEffectiveOperationModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEffectiveOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEffectiveControlModeAttribute(IntegerAttributeCallback callback) { + public void readEffectiveControlModeAttribute( + IntegerAttributeCallback callback + ) { readEffectiveControlModeAttribute(chipClusterPtr, callback); } - public void subscribeEffectiveControlModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEffectiveControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCapacityAttribute(IntegerAttributeCallback callback) { + public void readCapacityAttribute( + IntegerAttributeCallback callback + ) { readCapacityAttribute(chipClusterPtr, callback); } - public void subscribeCapacityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSpeedAttribute(IntegerAttributeCallback callback) { + public void readSpeedAttribute( + IntegerAttributeCallback callback + ) { readSpeedAttribute(chipClusterPtr, callback); } - public void subscribeSpeedAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLifetimeRunningHoursAttribute(LifetimeRunningHoursAttributeCallback callback) { + public void readLifetimeRunningHoursAttribute( + LifetimeRunningHoursAttributeCallback callback + ) { readLifetimeRunningHoursAttribute(chipClusterPtr, callback); } - public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value) { writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, null); } - public void writeLifetimeRunningHoursAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLifetimeRunningHoursAttribute( - LifetimeRunningHoursAttributeCallback callback, int minInterval, int maxInterval) { + LifetimeRunningHoursAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLifetimeRunningHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPowerAttribute(LongAttributeCallback callback) { + public void readPowerAttribute( + LongAttributeCallback callback + ) { readPowerAttribute(chipClusterPtr, callback); } - public void subscribePowerAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readLifetimeEnergyConsumedAttribute( - LifetimeEnergyConsumedAttributeCallback callback) { + LifetimeEnergyConsumedAttributeCallback callback + ) { readLifetimeEnergyConsumedAttribute(chipClusterPtr, callback); } - public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value) { writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, null); } - public void writeLifetimeEnergyConsumedAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLifetimeEnergyConsumedAttribute( - LifetimeEnergyConsumedAttributeCallback callback, int minInterval, int maxInterval) { + LifetimeEnergyConsumedAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperationModeAttribute(IntegerAttributeCallback callback) { + public void readOperationModeAttribute( + IntegerAttributeCallback callback + ) { readOperationModeAttribute(chipClusterPtr, callback); } - public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value) { writeOperationModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOperationModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOperationModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOperationModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readControlModeAttribute(IntegerAttributeCallback callback) { + public void readControlModeAttribute( + IntegerAttributeCallback callback + ) { readControlModeAttribute(chipClusterPtr, callback); } - public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value) { writeControlModeAttribute(chipClusterPtr, callback, value, null); } - public void writeControlModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeControlModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeControlModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAlarmMaskAttribute(IntegerAttributeCallback callback) { + public void readAlarmMaskAttribute( + IntegerAttributeCallback callback + ) { readAlarmMaskAttribute(chipClusterPtr, callback); } - public void subscribeAlarmMaskAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAlarmMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMaxPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + private native void readMaxPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinConstPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinConstPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxConstPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxConstPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinCompPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinCompPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxCompPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxCompPressureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinConstSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinConstSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxConstSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxConstSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinConstFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinConstFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxConstFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxConstFlowAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinConstTempAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinConstTempAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxConstTempAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxConstTempAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPumpStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePumpStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEffectiveOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEffectiveOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEffectiveControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEffectiveControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCapacityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCapacityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSpeedAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLifetimeRunningHoursAttribute(long chipClusterPtr, + LifetimeRunningHoursAttributeCallback callback + ); + + private native void writeLifetimeRunningHoursAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLifetimeRunningHoursAttribute(long chipClusterPtr, + LifetimeRunningHoursAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPowerAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePowerAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLifetimeEnergyConsumedAttribute(long chipClusterPtr, + LifetimeEnergyConsumedAttributeCallback callback + ); + + private native void writeLifetimeEnergyConsumedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLifetimeEnergyConsumedAttribute(long chipClusterPtr, + LifetimeEnergyConsumedAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOperationModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOperationModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeControlModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeControlModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAlarmMaskAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAlarmMaskAttribute(long chipClusterPtr, + IntegerAttributeCallback 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); + } - private native void subscribeMaxSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public static class RelativeHumidityMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1029L; - private native void readMaxFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } - private native void subscribeMaxFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + @Override + public native long initWithDevice(long devicePtr, int endpointId); - private native void readMinConstPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void subscribeMinConstPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + public void readMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + public void subscribeMeasuredValueAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readMaxConstPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxConstPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinCompPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinCompPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxCompPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxCompPressureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinConstSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinConstSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxConstSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxConstSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinConstFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinConstFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxConstFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxConstFlowAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinConstTempAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinConstTempAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxConstTempAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxConstTempAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPumpStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePumpStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEffectiveOperationModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeEffectiveOperationModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEffectiveControlModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeEffectiveControlModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCapacityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCapacityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSpeedAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSpeedAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLifetimeRunningHoursAttribute( - long chipClusterPtr, LifetimeRunningHoursAttributeCallback callback); - - private native void writeLifetimeRunningHoursAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLifetimeRunningHoursAttribute( - long chipClusterPtr, - LifetimeRunningHoursAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readPowerAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePowerAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLifetimeEnergyConsumedAttribute( - long chipClusterPtr, LifetimeEnergyConsumedAttributeCallback callback); - - private native void writeLifetimeEnergyConsumedAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLifetimeEnergyConsumedAttribute( - long chipClusterPtr, - LifetimeEnergyConsumedAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOperationModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOperationModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOperationModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readControlModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeControlModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeControlModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAlarmMaskAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAlarmMaskAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 RelativeHumidityMeasurementCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1029L; - - public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } - - @Override - public native long initWithDevice(long devicePtr, int endpointId); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { - readMeasuredValueAttribute(chipClusterPtr, callback); - } - - public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMinMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMaxMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute(IntegerAttributeCallback callback) { + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { readToleranceAttribute(chipClusterPtr, callback); } - public void subscribeToleranceAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ScenesCluster extends BaseChipCluster { @@ -11451,325 +10668,278 @@ public ScenesCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addScene( - AddSceneResponseCallback callback, - Integer groupId, - Integer sceneId, - Integer transitionTime, - String sceneName, - ArrayList extensionFieldSets) { - addScene( - chipClusterPtr, - callback, - groupId, - sceneId, - transitionTime, - sceneName, - extensionFieldSets, - null); - } - - public void addScene( - AddSceneResponseCallback callback, - Integer groupId, - Integer sceneId, - Integer transitionTime, - String sceneName, - ArrayList extensionFieldSets, - int timedInvokeTimeoutMs) { - addScene( - chipClusterPtr, - callback, - groupId, - sceneId, - transitionTime, - sceneName, - extensionFieldSets, - timedInvokeTimeoutMs); - } - - public void getSceneMembership(GetSceneMembershipResponseCallback callback, Integer groupId) { + public void addScene(AddSceneResponseCallback callback + , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { + addScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, sceneName, extensionFieldSets, null); + } + + public void addScene(AddSceneResponseCallback callback + , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets + , int timedInvokeTimeoutMs) { + addScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, sceneName, extensionFieldSets, timedInvokeTimeoutMs); + } + + public void getSceneMembership(GetSceneMembershipResponseCallback callback + , Integer groupId) { getSceneMembership(chipClusterPtr, callback, groupId, null); } - public void getSceneMembership( - GetSceneMembershipResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { + public void getSceneMembership(GetSceneMembershipResponseCallback callback + , Integer groupId + , int timedInvokeTimeoutMs) { getSceneMembership(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void recallScene( - DefaultClusterCallback callback, Integer groupId, Integer sceneId, Integer transitionTime) { + public void recallScene(DefaultClusterCallback callback + , Integer groupId, Integer sceneId, Integer transitionTime) { recallScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, null); } - public void recallScene( - DefaultClusterCallback callback, - Integer groupId, - Integer sceneId, - Integer transitionTime, - int timedInvokeTimeoutMs) { + public void recallScene(DefaultClusterCallback callback + , Integer groupId, Integer sceneId, Integer transitionTime + , int timedInvokeTimeoutMs) { recallScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, timedInvokeTimeoutMs); } - public void removeAllScenes(RemoveAllScenesResponseCallback callback, Integer groupId) { + public void removeAllScenes(RemoveAllScenesResponseCallback callback + , Integer groupId) { removeAllScenes(chipClusterPtr, callback, groupId, null); } - public void removeAllScenes( - RemoveAllScenesResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { + public void removeAllScenes(RemoveAllScenesResponseCallback callback + , Integer groupId + , int timedInvokeTimeoutMs) { removeAllScenes(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void removeScene( - RemoveSceneResponseCallback callback, Integer groupId, Integer sceneId) { + public void removeScene(RemoveSceneResponseCallback callback + , Integer groupId, Integer sceneId) { removeScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void removeScene( - RemoveSceneResponseCallback callback, - Integer groupId, - Integer sceneId, - int timedInvokeTimeoutMs) { + public void removeScene(RemoveSceneResponseCallback callback + , Integer groupId, Integer sceneId + , int timedInvokeTimeoutMs) { removeScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - public void storeScene(StoreSceneResponseCallback callback, Integer groupId, Integer sceneId) { + public void storeScene(StoreSceneResponseCallback callback + , Integer groupId, Integer sceneId) { storeScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void storeScene( - StoreSceneResponseCallback callback, - Integer groupId, - Integer sceneId, - int timedInvokeTimeoutMs) { + public void storeScene(StoreSceneResponseCallback callback + , Integer groupId, Integer sceneId + , int timedInvokeTimeoutMs) { storeScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - public void viewScene(ViewSceneResponseCallback callback, Integer groupId, Integer sceneId) { + public void viewScene(ViewSceneResponseCallback callback + , Integer groupId, Integer sceneId) { viewScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void viewScene( - ViewSceneResponseCallback callback, - Integer groupId, - Integer sceneId, - int timedInvokeTimeoutMs) { + public void viewScene(ViewSceneResponseCallback callback + , Integer groupId, Integer sceneId + , int timedInvokeTimeoutMs) { viewScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - - private native void addScene( - long chipClusterPtr, - AddSceneResponseCallback Callback, - Integer groupId, - Integer sceneId, - Integer transitionTime, - String sceneName, - ArrayList extensionFieldSets, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getSceneMembership( - long chipClusterPtr, - GetSceneMembershipResponseCallback Callback, - Integer groupId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void recallScene( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer groupId, - Integer sceneId, - Integer transitionTime, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeAllScenes( - long chipClusterPtr, - RemoveAllScenesResponseCallback Callback, - Integer groupId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void removeScene( - long chipClusterPtr, - RemoveSceneResponseCallback Callback, - Integer groupId, - Integer sceneId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void storeScene( - long chipClusterPtr, - StoreSceneResponseCallback Callback, - Integer groupId, - Integer sceneId, - @Nullable Integer timedInvokeTimeoutMs); - - private native void viewScene( - long chipClusterPtr, - ViewSceneResponseCallback Callback, - Integer groupId, - Integer sceneId, - @Nullable Integer timedInvokeTimeoutMs); - + private native void addScene(long chipClusterPtr, AddSceneResponseCallback Callback + , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets + , @Nullable Integer timedInvokeTimeoutMs); + private native void getSceneMembership(long chipClusterPtr, GetSceneMembershipResponseCallback Callback + , Integer groupId + , @Nullable Integer timedInvokeTimeoutMs); + private native void recallScene(long chipClusterPtr, DefaultClusterCallback Callback + , Integer groupId, Integer sceneId, Integer transitionTime + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeAllScenes(long chipClusterPtr, RemoveAllScenesResponseCallback Callback + , Integer groupId + , @Nullable Integer timedInvokeTimeoutMs); + private native void removeScene(long chipClusterPtr, RemoveSceneResponseCallback Callback + , Integer groupId, Integer sceneId + , @Nullable Integer timedInvokeTimeoutMs); + private native void storeScene(long chipClusterPtr, StoreSceneResponseCallback Callback + , Integer groupId, Integer sceneId + , @Nullable Integer timedInvokeTimeoutMs); + private native void viewScene(long chipClusterPtr, ViewSceneResponseCallback Callback + , Integer groupId, Integer sceneId + , @Nullable Integer timedInvokeTimeoutMs); public interface AddSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface GetSceneMembershipResponseCallback { - void onSuccess( - Integer status, - Integer capacity, - Integer groupId, - Integer sceneCount, - ArrayList sceneList); - + void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList); + void onError(Exception error); } public interface RemoveAllScenesResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface RemoveSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface StoreSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface ViewSceneResponseCallback { - void onSuccess( - Integer status, - Integer groupId, - Integer sceneId, - Integer transitionTime, - String sceneName, - ArrayList extensionFieldSets); - + void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets); + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readSceneCountAttribute(IntegerAttributeCallback callback) { + public void readSceneCountAttribute( + IntegerAttributeCallback callback + ) { readSceneCountAttribute(chipClusterPtr, callback); } - public void subscribeSceneCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSceneCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentSceneAttribute(IntegerAttributeCallback callback) { + public void readCurrentSceneAttribute( + IntegerAttributeCallback callback + ) { readCurrentSceneAttribute(chipClusterPtr, callback); } - public void subscribeCurrentSceneAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentSceneAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentGroupAttribute(IntegerAttributeCallback callback) { + public void readCurrentGroupAttribute( + IntegerAttributeCallback callback + ) { readCurrentGroupAttribute(chipClusterPtr, callback); } - public void subscribeCurrentGroupAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentGroupAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSceneValidAttribute(BooleanAttributeCallback callback) { + public void readSceneValidAttribute( + BooleanAttributeCallback callback + ) { readSceneValidAttribute(chipClusterPtr, callback); } - public void subscribeSceneValidAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSceneValidAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNameSupportAttribute(IntegerAttributeCallback callback) { + public void readNameSupportAttribute( + IntegerAttributeCallback callback + ) { readNameSupportAttribute(chipClusterPtr, callback); } - public void subscribeNameSupportAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSceneCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSceneCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentSceneAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentSceneAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentGroupAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentGroupAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSceneValidAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void subscribeSceneValidAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNameSupportAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNameSupportAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readSceneCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSceneCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentSceneAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentSceneAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentGroupAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentGroupAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSceneValidAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + private native void subscribeSceneValidAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNameSupportAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class SoftwareDiagnosticsCluster extends BaseChipCluster { @@ -11782,147 +10952,163 @@ public SoftwareDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetWatermarks(DefaultClusterCallback callback) { + public void resetWatermarks(DefaultClusterCallback callback + ) { resetWatermarks(chipClusterPtr, callback, null); } - public void resetWatermarks(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void resetWatermarks(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { resetWatermarks(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void resetWatermarks(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); - private native void resetWatermarks( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface ThreadMetricsAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface ThreadMetricsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readThreadMetricsAttribute(ThreadMetricsAttributeCallback callback) { + public void readThreadMetricsAttribute( + ThreadMetricsAttributeCallback callback + ) { readThreadMetricsAttribute(chipClusterPtr, callback); } - public void subscribeThreadMetricsAttribute( - ThreadMetricsAttributeCallback callback, int minInterval, int maxInterval) { + ThreadMetricsAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeThreadMetricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapFreeAttribute(LongAttributeCallback callback) { + public void readCurrentHeapFreeAttribute( + LongAttributeCallback callback + ) { readCurrentHeapFreeAttribute(chipClusterPtr, callback); } - public void subscribeCurrentHeapFreeAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentHeapFreeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapUsedAttribute(LongAttributeCallback callback) { + public void readCurrentHeapUsedAttribute( + LongAttributeCallback callback + ) { readCurrentHeapUsedAttribute(chipClusterPtr, callback); } - public void subscribeCurrentHeapUsedAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentHeapUsedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapHighWatermarkAttribute(LongAttributeCallback callback) { + public void readCurrentHeapHighWatermarkAttribute( + LongAttributeCallback callback + ) { readCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback); } - public void subscribeCurrentHeapHighWatermarkAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeCurrentHeapHighWatermarkAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readThreadMetricsAttribute( - long chipClusterPtr, ThreadMetricsAttributeCallback callback); - - private native void subscribeThreadMetricsAttribute( - long chipClusterPtr, - ThreadMetricsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentHeapFreeAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeCurrentHeapFreeAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentHeapUsedAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeCurrentHeapUsedAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentHeapHighWatermarkAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeCurrentHeapHighWatermarkAttribute( - long chipClusterPtr, LongAttributeCallback 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); + private native void readThreadMetricsAttribute(long chipClusterPtr, + ThreadMetricsAttributeCallback callback + ); + private native void subscribeThreadMetricsAttribute(long chipClusterPtr, + ThreadMetricsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentHeapFreeAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCurrentHeapFreeAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentHeapUsedAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCurrentHeapUsedAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentHeapHighWatermarkAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCurrentHeapHighWatermarkAttribute(long chipClusterPtr, + LongAttributeCallback 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 SwitchCluster extends BaseChipCluster { @@ -11935,106 +11121,125 @@ public SwitchCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readNumberOfPositionsAttribute(IntegerAttributeCallback callback) { + public void readNumberOfPositionsAttribute( + IntegerAttributeCallback callback + ) { readNumberOfPositionsAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfPositionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNumberOfPositionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionAttribute(IntegerAttributeCallback callback) { + public void readCurrentPositionAttribute( + IntegerAttributeCallback callback + ) { readCurrentPositionAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMultiPressMaxAttribute(IntegerAttributeCallback callback) { + public void readMultiPressMaxAttribute( + IntegerAttributeCallback callback + ) { readMultiPressMaxAttribute(chipClusterPtr, callback); } - public void subscribeMultiPressMaxAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMultiPressMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNumberOfPositionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfPositionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentPositionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentPositionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMultiPressMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMultiPressMaxAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readNumberOfPositionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfPositionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentPositionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMultiPressMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMultiPressMaxAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 TargetNavigatorCluster extends BaseChipCluster { @@ -12047,113 +11252,112 @@ public TargetNavigatorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void navigateTargetRequest( - NavigateTargetResponseCallback callback, Integer target, String data) { + public void navigateTargetRequest(NavigateTargetResponseCallback callback + , Integer target, String data) { navigateTargetRequest(chipClusterPtr, callback, target, data, null); } - public void navigateTargetRequest( - NavigateTargetResponseCallback callback, - Integer target, - String data, - int timedInvokeTimeoutMs) { + public void navigateTargetRequest(NavigateTargetResponseCallback callback + , Integer target, String data + , int timedInvokeTimeoutMs) { navigateTargetRequest(chipClusterPtr, callback, target, data, timedInvokeTimeoutMs); } - - private native void navigateTargetRequest( - long chipClusterPtr, - NavigateTargetResponseCallback Callback, - Integer target, - String data, - @Nullable Integer timedInvokeTimeoutMs); - + private native void navigateTargetRequest(long chipClusterPtr, NavigateTargetResponseCallback Callback + , Integer target, String data + , @Nullable Integer timedInvokeTimeoutMs); public interface NavigateTargetResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } - public interface TargetNavigatorListAttributeCallback { - void onSuccess(List valueList); - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface TargetNavigatorListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readTargetNavigatorListAttribute(TargetNavigatorListAttributeCallback callback) { + public void readTargetNavigatorListAttribute( + TargetNavigatorListAttributeCallback callback + ) { readTargetNavigatorListAttribute(chipClusterPtr, callback); } - public void subscribeTargetNavigatorListAttribute( - TargetNavigatorListAttributeCallback callback, int minInterval, int maxInterval) { + TargetNavigatorListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeTargetNavigatorListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentNavigatorTargetAttribute(IntegerAttributeCallback callback) { + public void readCurrentNavigatorTargetAttribute( + IntegerAttributeCallback callback + ) { readCurrentNavigatorTargetAttribute(chipClusterPtr, callback); } - public void subscribeCurrentNavigatorTargetAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentNavigatorTargetAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTargetNavigatorListAttribute( - long chipClusterPtr, TargetNavigatorListAttributeCallback callback); - - private native void subscribeTargetNavigatorListAttribute( - long chipClusterPtr, - TargetNavigatorListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentNavigatorTargetAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeCurrentNavigatorTargetAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readTargetNavigatorListAttribute(long chipClusterPtr, + TargetNavigatorListAttributeCallback callback + ); + private native void subscribeTargetNavigatorListAttribute(long chipClusterPtr, + TargetNavigatorListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentNavigatorTargetAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeCurrentNavigatorTargetAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class TemperatureMeasurementCluster extends BaseChipCluster { @@ -12166,3268 +11370,2838 @@ public TemperatureMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMinMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { + public void readMaxMeasuredValueAttribute( + IntegerAttributeCallback callback + ) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } - public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute(IntegerAttributeCallback callback) { + public void readToleranceAttribute( + IntegerAttributeCallback callback + ) { readToleranceAttribute(chipClusterPtr, callback); } - public void subscribeToleranceAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + 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 readMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMinMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeMaxMeasuredValueAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeToleranceAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - } - - public static class TestClusterCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1295L; - - public TestClusterCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } - - @Override - public native long initWithDevice(long devicePtr, int endpointId); - - public void simpleStructEchoRequest( - SimpleStructResponseCallback callback, ChipStructs.TestClusterClusterSimpleStruct arg1) { - simpleStructEchoRequest(chipClusterPtr, callback, arg1, null); - } - - public void simpleStructEchoRequest( - SimpleStructResponseCallback callback, - ChipStructs.TestClusterClusterSimpleStruct arg1, - int timedInvokeTimeoutMs) { - simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void test(DefaultClusterCallback callback) { - test(chipClusterPtr, callback, null); - } - - public void test(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - test(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - public void testAddArguments( - TestAddArgumentsResponseCallback callback, Integer arg1, Integer arg2) { - testAddArguments(chipClusterPtr, callback, arg1, arg2, null); - } - - public void testAddArguments( - TestAddArgumentsResponseCallback callback, - Integer arg1, - Integer arg2, - int timedInvokeTimeoutMs) { - testAddArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); - } - - public void testEmitTestEventRequest( - TestEmitTestEventResponseCallback callback, Integer arg1, Integer arg2, Boolean arg3) { - testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, null); - } - - public void testEmitTestEventRequest( - TestEmitTestEventResponseCallback callback, - Integer arg1, - Integer arg2, - Boolean arg3, - int timedInvokeTimeoutMs) { - testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, timedInvokeTimeoutMs); - } - - public void testEnumsRequest(TestEnumsResponseCallback callback, Integer arg1, Integer arg2) { - testEnumsRequest(chipClusterPtr, callback, arg1, arg2, null); - } - - public void testEnumsRequest( - TestEnumsResponseCallback callback, Integer arg1, Integer arg2, int timedInvokeTimeoutMs) { - testEnumsRequest(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); - } - - public void testListInt8UArgumentRequest( - BooleanResponseCallback callback, ArrayList arg1) { - testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testListInt8UArgumentRequest( - BooleanResponseCallback callback, ArrayList arg1, int timedInvokeTimeoutMs) { - testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testListInt8UReverseRequest( - TestListInt8UReverseResponseCallback callback, ArrayList arg1) { - testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null); - } - - public void testListInt8UReverseRequest( - TestListInt8UReverseResponseCallback callback, - ArrayList arg1, - int timedInvokeTimeoutMs) { - testListInt8UReverseRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testListNestedStructListArgumentRequest( - BooleanResponseCallback callback, - ArrayList arg1) { - testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testListNestedStructListArgumentRequest( - BooleanResponseCallback callback, - ArrayList arg1, - int timedInvokeTimeoutMs) { - testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testListStructArgumentRequest( - BooleanResponseCallback callback, - ArrayList arg1) { - testListStructArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testListStructArgumentRequest( - BooleanResponseCallback callback, - ArrayList arg1, - int timedInvokeTimeoutMs) { - testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testNestedStructArgumentRequest( - BooleanResponseCallback callback, ChipStructs.TestClusterClusterNestedStruct arg1) { - testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testNestedStructArgumentRequest( - BooleanResponseCallback callback, - ChipStructs.TestClusterClusterNestedStruct arg1, - int timedInvokeTimeoutMs) { - testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testNestedStructListArgumentRequest( - BooleanResponseCallback callback, ChipStructs.TestClusterClusterNestedStructList arg1) { - testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testNestedStructListArgumentRequest( - BooleanResponseCallback callback, - ChipStructs.TestClusterClusterNestedStructList arg1, - int timedInvokeTimeoutMs) { - testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testNotHandled(DefaultClusterCallback callback) { - testNotHandled(chipClusterPtr, callback, null); - } - - public void testNotHandled(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - public void testNullableOptionalRequest( - TestNullableOptionalResponseCallback callback, @Nullable Optional arg1) { - testNullableOptionalRequest(chipClusterPtr, callback, arg1, null); - } - - public void testNullableOptionalRequest( - TestNullableOptionalResponseCallback callback, - @Nullable Optional arg1, - int timedInvokeTimeoutMs) { - testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testSimpleOptionalArgumentRequest( - DefaultClusterCallback callback, Optional arg1) { - testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testSimpleOptionalArgumentRequest( - DefaultClusterCallback callback, Optional arg1, int timedInvokeTimeoutMs) { - testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testSpecific(TestSpecificResponseCallback callback) { - testSpecific(chipClusterPtr, callback, null); - } - - public void testSpecific(TestSpecificResponseCallback callback, int timedInvokeTimeoutMs) { - - testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - public void testStructArgumentRequest( - BooleanResponseCallback callback, ChipStructs.TestClusterClusterSimpleStruct arg1) { - testStructArgumentRequest(chipClusterPtr, callback, arg1, null); - } - - public void testStructArgumentRequest( - BooleanResponseCallback callback, - ChipStructs.TestClusterClusterSimpleStruct arg1, - int timedInvokeTimeoutMs) { - testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } - - public void testUnknownCommand(DefaultClusterCallback callback) { - testUnknownCommand(chipClusterPtr, callback, null); - } - - public void testUnknownCommand(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - public void timedInvokeRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - private native void simpleStructEchoRequest( - long chipClusterPtr, - SimpleStructResponseCallback Callback, - ChipStructs.TestClusterClusterSimpleStruct arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void test( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testAddArguments( - long chipClusterPtr, - TestAddArgumentsResponseCallback Callback, - Integer arg1, - Integer arg2, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testEmitTestEventRequest( - long chipClusterPtr, - TestEmitTestEventResponseCallback Callback, - Integer arg1, - Integer arg2, - Boolean arg3, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testEnumsRequest( - long chipClusterPtr, - TestEnumsResponseCallback Callback, - Integer arg1, - Integer arg2, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testListInt8UArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ArrayList arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testListInt8UReverseRequest( - long chipClusterPtr, - TestListInt8UReverseResponseCallback Callback, - ArrayList arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testListNestedStructListArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ArrayList arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testListStructArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ArrayList arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testNestedStructArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ChipStructs.TestClusterClusterNestedStruct arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testNestedStructListArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ChipStructs.TestClusterClusterNestedStructList arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testNotHandled( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testNullableOptionalRequest( - long chipClusterPtr, - TestNullableOptionalResponseCallback Callback, - @Nullable Optional arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testSimpleOptionalArgumentRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - Optional arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testSpecific( - long chipClusterPtr, - TestSpecificResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testStructArgumentRequest( - long chipClusterPtr, - BooleanResponseCallback Callback, - ChipStructs.TestClusterClusterSimpleStruct arg1, - @Nullable Integer timedInvokeTimeoutMs); - - private native void testUnknownCommand( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void timedInvokeRequest( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface BooleanResponseCallback { - void onSuccess(Boolean value); - - void onError(Exception error); - } - - public interface SimpleStructResponseCallback { - void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); - - void onError(Exception error); - } - - public interface TestAddArgumentsResponseCallback { - void onSuccess(Integer returnValue); - - void onError(Exception error); - } - - public interface TestEmitTestEventResponseCallback { - void onSuccess(Long value); - - void onError(Exception error); - } - - public interface TestEnumsResponseCallback { - void onSuccess(Integer arg1, Integer arg2); - - void onError(Exception error); - } - - public interface TestListInt8UReverseResponseCallback { - void onSuccess(ArrayList arg1); - - void onError(Exception error); - } - - public interface TestNullableOptionalResponseCallback { - void onSuccess( - Boolean wasPresent, - Optional wasNull, - Optional value, - @Nullable Optional originalValue); - - void onError(Exception error); - } - - public interface TestSpecificResponseCallback { - void onSuccess(Integer returnValue); - - void onError(Exception error); - } - - public interface ListInt8uAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ListOctetStringAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ListStructOctetStringAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface VendorIdAttributeCallback { - void onSuccess(Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ListNullablesAndOptionalsStructAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface ListLongOctetStringAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableBooleanAttributeCallback { - void onSuccess(@Nullable Boolean value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableBitmap8AttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableBitmap16AttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableBitmap32AttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableBitmap64AttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt8uAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt16uAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt24uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt32uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt40uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt48uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt56uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt64uAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt8sAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface NullableInt16sAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public interface NullableInt24sAttributeCallback { - void onSuccess(@Nullable Long value); + private native void readMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeToleranceAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } - void onError(Exception ex); + public static class TestClusterCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1295L; - default void onSubscriptionEstablished() {} + public TestClusterCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); } - public interface NullableInt32sAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); + @Override + public native long initWithDevice(long devicePtr, int endpointId); - default void onSubscriptionEstablished() {} + public void simpleStructEchoRequest(SimpleStructResponseCallback callback + , ChipStructs.TestClusterClusterSimpleStruct arg1) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, null); } - public interface NullableInt40sAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void simpleStructEchoRequest(SimpleStructResponseCallback callback + , ChipStructs.TestClusterClusterSimpleStruct arg1 + , int timedInvokeTimeoutMs) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); } - public interface NullableInt48sAttributeCallback { - void onSuccess(@Nullable Long value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void test(DefaultClusterCallback callback + ) { + test(chipClusterPtr, callback, null); } - public interface NullableInt56sAttributeCallback { - void onSuccess(@Nullable Long value); + public void test(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + test(chipClusterPtr, callback, timedInvokeTimeoutMs); + } - void onError(Exception ex); + public void testAddArguments(TestAddArgumentsResponseCallback callback + , Integer arg1, Integer arg2) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, null); + } - default void onSubscriptionEstablished() {} + public void testAddArguments(TestAddArgumentsResponseCallback callback + , Integer arg1, Integer arg2 + , int timedInvokeTimeoutMs) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); } - public interface NullableInt64sAttributeCallback { - void onSuccess(@Nullable Long value); + public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback + , Integer arg1, Integer arg2, Boolean arg3) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, null); + } - void onError(Exception ex); + public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback + , Integer arg1, Integer arg2, Boolean arg3 + , int timedInvokeTimeoutMs) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, timedInvokeTimeoutMs); + } - default void onSubscriptionEstablished() {} + public void testEnumsRequest(TestEnumsResponseCallback callback + , Integer arg1, Integer arg2) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, null); } - public interface NullableEnum8AttributeCallback { - void onSuccess(@Nullable Integer value); + public void testEnumsRequest(TestEnumsResponseCallback callback + , Integer arg1, Integer arg2 + , int timedInvokeTimeoutMs) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + } - void onError(Exception ex); + public void testListInt8UArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null); + } - default void onSubscriptionEstablished() {} + public void testListInt8UArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); } - public interface NullableEnum16AttributeCallback { - void onSuccess(@Nullable Integer value); + public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback + , ArrayList arg1) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null); + } - void onError(Exception ex); + public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - default void onSubscriptionEstablished() {} + public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); } - public interface NullableFloatSingleAttributeCallback { - void onSuccess(@Nullable Float value); + public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - void onError(Exception ex); + public void testListStructArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } - default void onSubscriptionEstablished() {} + public void testListStructArgumentRequest(BooleanResponseCallback callback + , ArrayList arg1 + , int timedInvokeTimeoutMs) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); } - public interface NullableFloatDoubleAttributeCallback { - void onSuccess(@Nullable Double value); + public void testNestedStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterNestedStruct arg1) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } - void onError(Exception ex); + public void testNestedStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterNestedStruct arg1 + , int timedInvokeTimeoutMs) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - default void onSubscriptionEstablished() {} + public void testNestedStructListArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterNestedStructList arg1) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); } - public interface NullableOctetStringAttributeCallback { - void onSuccess(@Nullable byte[] value); + public void testNestedStructListArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterNestedStructList arg1 + , int timedInvokeTimeoutMs) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - void onError(Exception ex); + public void testNotHandled(DefaultClusterCallback callback + ) { + testNotHandled(chipClusterPtr, callback, null); + } - default void onSubscriptionEstablished() {} + public void testNotHandled(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public interface NullableCharStringAttributeCallback { - void onSuccess(@Nullable String value); + public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback + , @Nullable Optional arg1) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, null); + } - void onError(Exception ex); + public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback + , @Nullable Optional arg1 + , int timedInvokeTimeoutMs) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - default void onSubscriptionEstablished() {} + public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback + , Optional arg1) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null); } - public interface NullableEnumAttrAttributeCallback { - void onSuccess(@Nullable Integer value); + public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback + , Optional arg1 + , int timedInvokeTimeoutMs) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - void onError(Exception ex); + public void testSpecific(TestSpecificResponseCallback callback + ) { + testSpecific(chipClusterPtr, callback, null); + } - default void onSubscriptionEstablished() {} + public void testSpecific(TestSpecificResponseCallback callback + + , int timedInvokeTimeoutMs) { + testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public interface NullableRangeRestrictedInt8uAttributeCallback { - void onSuccess(@Nullable Integer value); + public void testStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterSimpleStruct arg1) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } - void onError(Exception ex); + public void testStructArgumentRequest(BooleanResponseCallback callback + , ChipStructs.TestClusterClusterSimpleStruct arg1 + , int timedInvokeTimeoutMs) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } - default void onSubscriptionEstablished() {} + public void testUnknownCommand(DefaultClusterCallback callback + ) { + testUnknownCommand(chipClusterPtr, callback, null); } - public interface NullableRangeRestrictedInt8sAttributeCallback { - void onSuccess(@Nullable Integer value); + public void testUnknownCommand(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); + } - void onError(Exception ex); - default void onSubscriptionEstablished() {} + public void timedInvokeRequest(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + private native void simpleStructEchoRequest(long chipClusterPtr, SimpleStructResponseCallback Callback + , ChipStructs.TestClusterClusterSimpleStruct arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void test(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void testAddArguments(long chipClusterPtr, TestAddArgumentsResponseCallback Callback + , Integer arg1, Integer arg2 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testEmitTestEventRequest(long chipClusterPtr, TestEmitTestEventResponseCallback Callback + , Integer arg1, Integer arg2, Boolean arg3 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testEnumsRequest(long chipClusterPtr, TestEnumsResponseCallback Callback + , Integer arg1, Integer arg2 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListInt8UArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListInt8UReverseRequest(long chipClusterPtr, TestListInt8UReverseResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testListStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ArrayList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNestedStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ChipStructs.TestClusterClusterNestedStruct arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ChipStructs.TestClusterClusterNestedStructList arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNotHandled(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void testNullableOptionalRequest(long chipClusterPtr, TestNullableOptionalResponseCallback Callback + , @Nullable Optional arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testSimpleOptionalArgumentRequest(long chipClusterPtr, DefaultClusterCallback Callback + , Optional arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testSpecific(long chipClusterPtr, TestSpecificResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void testStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback + , ChipStructs.TestClusterClusterSimpleStruct arg1 + , @Nullable Integer timedInvokeTimeoutMs); + private native void testUnknownCommand(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void timedInvokeRequest(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + public interface BooleanResponseCallback { + void onSuccess(Boolean value); + + void onError(Exception error); } - public interface NullableRangeRestrictedInt16uAttributeCallback { - void onSuccess(@Nullable Integer value); + public interface SimpleStructResponseCallback { + void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); + + void onError(Exception error); + } - void onError(Exception ex); + public interface TestAddArgumentsResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } - default void onSubscriptionEstablished() {} + public interface TestEmitTestEventResponseCallback { + void onSuccess(Long value); + + void onError(Exception error); } - public interface NullableRangeRestrictedInt16sAttributeCallback { - void onSuccess(@Nullable Integer value); + public interface TestEnumsResponseCallback { + void onSuccess(Integer arg1, Integer arg2); + + void onError(Exception error); + } - void onError(Exception ex); + public interface TestListInt8UReverseResponseCallback { + void onSuccess(ArrayList arg1); + + void onError(Exception error); + } - default void onSubscriptionEstablished() {} + public interface TestNullableOptionalResponseCallback { + void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue); + + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); + public interface TestSpecificResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface ListInt8uAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ListOctetStringAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ListStructOctetStringAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface VendorIdAttributeCallback { + void onSuccess( Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ListNullablesAndOptionalsStructAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ListLongOctetStringAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableBooleanAttributeCallback { + void onSuccess(@Nullable Boolean value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableBitmap8AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableBitmap16AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableBitmap32AttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableBitmap64AttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt24uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt32uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt40uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt48uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt56uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt64uAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt24sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt32sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt40sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt48sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt56sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableInt64sAttributeCallback { + void onSuccess(@Nullable Long value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableEnum8AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableEnum16AttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableFloatSingleAttributeCallback { + void onSuccess(@Nullable Float value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableFloatDoubleAttributeCallback { + void onSuccess(@Nullable Double value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableOctetStringAttributeCallback { + void onSuccess(@Nullable byte[] value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableCharStringAttributeCallback { + void onSuccess(@Nullable String value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableEnumAttrAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableRangeRestrictedInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableRangeRestrictedInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableRangeRestrictedInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface NullableRangeRestrictedInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readBooleanAttribute(BooleanAttributeCallback callback) { + public void readBooleanAttribute( + BooleanAttributeCallback callback + ) { readBooleanAttribute(chipClusterPtr, callback); } - public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeBooleanAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBooleanAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap8Attribute(IntegerAttributeCallback callback) { + public void readBitmap8Attribute( + IntegerAttributeCallback callback + ) { readBitmap8Attribute(chipClusterPtr, callback); } - public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value) { writeBitmap8Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap8Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBitmap8Attribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap16Attribute(IntegerAttributeCallback callback) { + public void readBitmap16Attribute( + IntegerAttributeCallback callback + ) { readBitmap16Attribute(chipClusterPtr, callback); } - public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value) { writeBitmap16Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap16Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBitmap16Attribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap32Attribute(LongAttributeCallback callback) { + public void readBitmap32Attribute( + LongAttributeCallback callback + ) { readBitmap32Attribute(chipClusterPtr, callback); } - public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value) { writeBitmap32Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap32Attribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBitmap32Attribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap64Attribute(LongAttributeCallback callback) { + public void readBitmap64Attribute( + LongAttributeCallback callback + ) { readBitmap64Attribute(chipClusterPtr, callback); } - public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value) { writeBitmap64Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap64Attribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeBitmap64Attribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt8uAttribute(IntegerAttributeCallback callback) { + public void readInt8uAttribute( + IntegerAttributeCallback callback + ) { readInt8uAttribute(chipClusterPtr, callback); } - public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt8uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt8uAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt16uAttribute(IntegerAttributeCallback callback) { + public void readInt16uAttribute( + IntegerAttributeCallback callback + ) { readInt16uAttribute(chipClusterPtr, callback); } - public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt16uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt16uAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt24uAttribute(LongAttributeCallback callback) { + public void readInt24uAttribute( + LongAttributeCallback callback + ) { readInt24uAttribute(chipClusterPtr, callback); } - public void writeInt24uAttribute(DefaultClusterCallback callback, Long value) { writeInt24uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt24uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt24uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt32uAttribute(LongAttributeCallback callback) { + public void readInt32uAttribute( + LongAttributeCallback callback + ) { readInt32uAttribute(chipClusterPtr, callback); } - public void writeInt32uAttribute(DefaultClusterCallback callback, Long value) { writeInt32uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt32uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt32uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt40uAttribute(LongAttributeCallback callback) { + public void readInt40uAttribute( + LongAttributeCallback callback + ) { readInt40uAttribute(chipClusterPtr, callback); } - public void writeInt40uAttribute(DefaultClusterCallback callback, Long value) { writeInt40uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt40uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt40uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt48uAttribute(LongAttributeCallback callback) { + public void readInt48uAttribute( + LongAttributeCallback callback + ) { readInt48uAttribute(chipClusterPtr, callback); } - public void writeInt48uAttribute(DefaultClusterCallback callback, Long value) { writeInt48uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt48uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt48uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt56uAttribute(LongAttributeCallback callback) { + public void readInt56uAttribute( + LongAttributeCallback callback + ) { readInt56uAttribute(chipClusterPtr, callback); } - public void writeInt56uAttribute(DefaultClusterCallback callback, Long value) { writeInt56uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt56uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt56uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt64uAttribute(LongAttributeCallback callback) { + public void readInt64uAttribute( + LongAttributeCallback callback + ) { readInt64uAttribute(chipClusterPtr, callback); } - public void writeInt64uAttribute(DefaultClusterCallback callback, Long value) { writeInt64uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt64uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt64uAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt8sAttribute(IntegerAttributeCallback callback) { + public void readInt8sAttribute( + IntegerAttributeCallback callback + ) { readInt8sAttribute(chipClusterPtr, callback); } - public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt8sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt8sAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt16sAttribute(IntegerAttributeCallback callback) { + public void readInt16sAttribute( + IntegerAttributeCallback callback + ) { readInt16sAttribute(chipClusterPtr, callback); } - public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt16sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt16sAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt24sAttribute(LongAttributeCallback callback) { + public void readInt24sAttribute( + LongAttributeCallback callback + ) { readInt24sAttribute(chipClusterPtr, callback); } - public void writeInt24sAttribute(DefaultClusterCallback callback, Long value) { writeInt24sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt24sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt24sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt32sAttribute(LongAttributeCallback callback) { + public void readInt32sAttribute( + LongAttributeCallback callback + ) { readInt32sAttribute(chipClusterPtr, callback); } - public void writeInt32sAttribute(DefaultClusterCallback callback, Long value) { writeInt32sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt32sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt32sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt40sAttribute(LongAttributeCallback callback) { + public void readInt40sAttribute( + LongAttributeCallback callback + ) { readInt40sAttribute(chipClusterPtr, callback); } - public void writeInt40sAttribute(DefaultClusterCallback callback, Long value) { writeInt40sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt40sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt40sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt48sAttribute(LongAttributeCallback callback) { + public void readInt48sAttribute( + LongAttributeCallback callback + ) { readInt48sAttribute(chipClusterPtr, callback); } - public void writeInt48sAttribute(DefaultClusterCallback callback, Long value) { writeInt48sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt48sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt48sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt56sAttribute(LongAttributeCallback callback) { + public void readInt56sAttribute( + LongAttributeCallback callback + ) { readInt56sAttribute(chipClusterPtr, callback); } - public void writeInt56sAttribute(DefaultClusterCallback callback, Long value) { writeInt56sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt56sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt56sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt64sAttribute(LongAttributeCallback callback) { + public void readInt64sAttribute( + LongAttributeCallback callback + ) { readInt64sAttribute(chipClusterPtr, callback); } - public void writeInt64sAttribute(DefaultClusterCallback callback, Long value) { writeInt64sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt64sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeInt64sAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnum8Attribute(IntegerAttributeCallback callback) { + public void readEnum8Attribute( + IntegerAttributeCallback callback + ) { readEnum8Attribute(chipClusterPtr, callback); } - public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value) { writeEnum8Attribute(chipClusterPtr, callback, value, null); } - public void writeEnum8Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEnum8Attribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnum16Attribute(IntegerAttributeCallback callback) { + public void readEnum16Attribute( + IntegerAttributeCallback callback + ) { readEnum16Attribute(chipClusterPtr, callback); } - public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value) { writeEnum16Attribute(chipClusterPtr, callback, value, null); } - public void writeEnum16Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEnum16Attribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFloatSingleAttribute(FloatAttributeCallback callback) { + public void readFloatSingleAttribute( + FloatAttributeCallback callback + ) { readFloatSingleAttribute(chipClusterPtr, callback); } - public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value) { writeFloatSingleAttribute(chipClusterPtr, callback, value, null); } - public void writeFloatSingleAttribute( - DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { writeFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeFloatSingleAttribute( - FloatAttributeCallback callback, int minInterval, int maxInterval) { + FloatAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFloatDoubleAttribute(DoubleAttributeCallback callback) { + public void readFloatDoubleAttribute( + DoubleAttributeCallback callback + ) { readFloatDoubleAttribute(chipClusterPtr, callback); } - public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { writeFloatDoubleAttribute(chipClusterPtr, callback, value, null); } - public void writeFloatDoubleAttribute( - DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { writeFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeFloatDoubleAttribute( - DoubleAttributeCallback callback, int minInterval, int maxInterval) { + DoubleAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOctetStringAttribute(OctetStringAttributeCallback callback) { + public void readOctetStringAttribute( + OctetStringAttributeCallback callback + ) { readOctetStringAttribute(chipClusterPtr, callback); } - public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeOctetStringAttribute( - DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOctetStringAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListInt8uAttribute(ListInt8uAttributeCallback callback) { + public void readListInt8uAttribute( + ListInt8uAttributeCallback callback + ) { readListInt8uAttribute(chipClusterPtr, callback); } - public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value) { writeListInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeListInt8uAttribute( - DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeListInt8uAttribute( - ListInt8uAttributeCallback callback, int minInterval, int maxInterval) { + ListInt8uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeListInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListOctetStringAttribute(ListOctetStringAttributeCallback callback) { + public void readListOctetStringAttribute( + ListOctetStringAttributeCallback callback + ) { readListOctetStringAttribute(chipClusterPtr, callback); } - - public void writeListOctetStringAttribute( - DefaultClusterCallback callback, ArrayList value) { + public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { writeListOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeListOctetStringAttribute( - DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeListOctetStringAttribute( - ListOctetStringAttributeCallback callback, int minInterval, int maxInterval) { + ListOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeListOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readListStructOctetStringAttribute( - ListStructOctetStringAttributeCallback callback) { + ListStructOctetStringAttributeCallback callback + ) { readListStructOctetStringAttribute(chipClusterPtr, callback); } - - public void writeListStructOctetStringAttribute( - DefaultClusterCallback callback, - ArrayList value) { + public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { writeListStructOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeListStructOctetStringAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { + public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListStructOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeListStructOctetStringAttribute( - ListStructOctetStringAttributeCallback callback, int minInterval, int maxInterval) { + ListStructOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeListStructOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLongOctetStringAttribute(OctetStringAttributeCallback callback) { + public void readLongOctetStringAttribute( + OctetStringAttributeCallback callback + ) { readLongOctetStringAttribute(chipClusterPtr, callback); } - public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeLongOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeLongOctetStringAttribute( - DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeLongOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLongOctetStringAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCharStringAttribute(CharStringAttributeCallback callback) { + public void readCharStringAttribute( + CharStringAttributeCallback callback + ) { readCharStringAttribute(chipClusterPtr, callback); } - public void writeCharStringAttribute(DefaultClusterCallback callback, String value) { writeCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeCharStringAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeCharStringAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLongCharStringAttribute(CharStringAttributeCallback callback) { + public void readLongCharStringAttribute( + CharStringAttributeCallback callback + ) { readLongCharStringAttribute(chipClusterPtr, callback); } - public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value) { writeLongCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeLongCharStringAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLongCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLongCharStringAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLongCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEpochUsAttribute(LongAttributeCallback callback) { + public void readEpochUsAttribute( + LongAttributeCallback callback + ) { readEpochUsAttribute(chipClusterPtr, callback); } - public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value) { writeEpochUsAttribute(chipClusterPtr, callback, value, null); } - public void writeEpochUsAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeEpochUsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEpochUsAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEpochUsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEpochSAttribute(LongAttributeCallback callback) { + public void readEpochSAttribute( + LongAttributeCallback callback + ) { readEpochSAttribute(chipClusterPtr, callback); } - public void writeEpochSAttribute(DefaultClusterCallback callback, Long value) { writeEpochSAttribute(chipClusterPtr, callback, value, null); } - public void writeEpochSAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeEpochSAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeEpochSAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEpochSAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEpochSAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIdAttribute(VendorIdAttributeCallback callback) { + public void readVendorIdAttribute( + VendorIdAttributeCallback callback + ) { readVendorIdAttribute(chipClusterPtr, callback); } - public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value) { writeVendorIdAttribute(chipClusterPtr, callback, value, null); } - public void writeVendorIdAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeVendorIdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeVendorIdAttribute( - VendorIdAttributeCallback callback, int minInterval, int maxInterval) { + VendorIdAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readListNullablesAndOptionalsStructAttribute( - ListNullablesAndOptionalsStructAttributeCallback callback) { + ListNullablesAndOptionalsStructAttributeCallback callback + ) { readListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback); } - - public void writeListNullablesAndOptionalsStructAttribute( - DefaultClusterCallback callback, - ArrayList value) { + public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value) { writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, null); } - public void writeListNullablesAndOptionalsStructAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { - writeListNullablesAndOptionalsStructAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeListNullablesAndOptionalsStructAttribute( - ListNullablesAndOptionalsStructAttributeCallback callback, - int minInterval, - int maxInterval) { - subscribeListNullablesAndOptionalsStructAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + ListNullablesAndOptionalsStructAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnumAttrAttribute(IntegerAttributeCallback callback) { + public void readEnumAttrAttribute( + IntegerAttributeCallback callback + ) { readEnumAttrAttribute(chipClusterPtr, callback); } - public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { writeEnumAttrAttribute(chipClusterPtr, callback, value, null); } - public void writeEnumAttrAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeEnumAttrAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt8uAttribute(IntegerAttributeCallback callback) { + public void readRangeRestrictedInt8uAttribute( + IntegerAttributeCallback callback + ) { readRangeRestrictedInt8uAttribute(chipClusterPtr, callback); } - public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt8uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeRangeRestrictedInt8uAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt8sAttribute(IntegerAttributeCallback callback) { + public void readRangeRestrictedInt8sAttribute( + IntegerAttributeCallback callback + ) { readRangeRestrictedInt8sAttribute(chipClusterPtr, callback); } - public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt8sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeRangeRestrictedInt8sAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt16uAttribute(IntegerAttributeCallback callback) { + public void readRangeRestrictedInt16uAttribute( + IntegerAttributeCallback callback + ) { readRangeRestrictedInt16uAttribute(chipClusterPtr, callback); } - - public void writeRangeRestrictedInt16uAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt16uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeRangeRestrictedInt16uAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt16sAttribute(IntegerAttributeCallback callback) { + public void readRangeRestrictedInt16sAttribute( + IntegerAttributeCallback callback + ) { readRangeRestrictedInt16sAttribute(chipClusterPtr, callback); } - - public void writeRangeRestrictedInt16sAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt16sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeRangeRestrictedInt16sAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListLongOctetStringAttribute(ListLongOctetStringAttributeCallback callback) { + public void readListLongOctetStringAttribute( + ListLongOctetStringAttributeCallback callback + ) { readListLongOctetStringAttribute(chipClusterPtr, callback); } - public void subscribeListLongOctetStringAttribute( - ListLongOctetStringAttributeCallback callback, int minInterval, int maxInterval) { + ListLongOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeListLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTimedWriteBooleanAttribute(BooleanAttributeCallback callback) { + public void readTimedWriteBooleanAttribute( + BooleanAttributeCallback callback + ) { readTimedWriteBooleanAttribute(chipClusterPtr, callback); } - public void writeTimedWriteBooleanAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeTimedWriteBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeTimedWriteBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeTimedWriteBooleanAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTimedWriteBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGeneralErrorBooleanAttribute(BooleanAttributeCallback callback) { + public void readGeneralErrorBooleanAttribute( + BooleanAttributeCallback callback + ) { readGeneralErrorBooleanAttribute(chipClusterPtr, callback); } - public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeGeneralErrorBooleanAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeGeneralErrorBooleanAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeGeneralErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterErrorBooleanAttribute(BooleanAttributeCallback callback) { + public void readClusterErrorBooleanAttribute( + BooleanAttributeCallback callback + ) { readClusterErrorBooleanAttribute(chipClusterPtr, callback); } - public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeClusterErrorBooleanAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeClusterErrorBooleanAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUnsupportedAttribute(BooleanAttributeCallback callback) { + public void readUnsupportedAttribute( + BooleanAttributeCallback callback + ) { readUnsupportedAttribute(chipClusterPtr, callback); } - public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value) { writeUnsupportedAttribute(chipClusterPtr, callback, value, null); } - public void writeUnsupportedAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeUnsupportedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeUnsupportedAttribute( - BooleanAttributeCallback callback, int minInterval, int maxInterval) { + BooleanAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeUnsupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBooleanAttribute(NullableBooleanAttributeCallback callback) { + public void readNullableBooleanAttribute( + NullableBooleanAttributeCallback callback + ) { readNullableBooleanAttribute(chipClusterPtr, callback); } - public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeNullableBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableBooleanAttribute( - DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeNullableBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableBooleanAttribute( - NullableBooleanAttributeCallback callback, int minInterval, int maxInterval) { + NullableBooleanAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap8Attribute(NullableBitmap8AttributeCallback callback) { + public void readNullableBitmap8Attribute( + NullableBitmap8AttributeCallback callback + ) { readNullableBitmap8Attribute(chipClusterPtr, callback); } - public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value) { writeNullableBitmap8Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap8Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableBitmap8Attribute( - NullableBitmap8AttributeCallback callback, int minInterval, int maxInterval) { + NullableBitmap8AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap16Attribute(NullableBitmap16AttributeCallback callback) { + public void readNullableBitmap16Attribute( + NullableBitmap16AttributeCallback callback + ) { readNullableBitmap16Attribute(chipClusterPtr, callback); } - public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value) { writeNullableBitmap16Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap16Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableBitmap16Attribute( - NullableBitmap16AttributeCallback callback, int minInterval, int maxInterval) { + NullableBitmap16AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap32Attribute(NullableBitmap32AttributeCallback callback) { + public void readNullableBitmap32Attribute( + NullableBitmap32AttributeCallback callback + ) { readNullableBitmap32Attribute(chipClusterPtr, callback); } - public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value) { writeNullableBitmap32Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap32Attribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableBitmap32Attribute( - NullableBitmap32AttributeCallback callback, int minInterval, int maxInterval) { + NullableBitmap32AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap64Attribute(NullableBitmap64AttributeCallback callback) { + public void readNullableBitmap64Attribute( + NullableBitmap64AttributeCallback callback + ) { readNullableBitmap64Attribute(chipClusterPtr, callback); } - public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value) { writeNullableBitmap64Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap64Attribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableBitmap64Attribute( - NullableBitmap64AttributeCallback callback, int minInterval, int maxInterval) { + NullableBitmap64AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt8uAttribute(NullableInt8uAttributeCallback callback) { + public void readNullableInt8uAttribute( + NullableInt8uAttributeCallback callback + ) { readNullableInt8uAttribute(chipClusterPtr, callback); } - public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt8uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt8uAttribute( - NullableInt8uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt8uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt16uAttribute(NullableInt16uAttributeCallback callback) { + public void readNullableInt16uAttribute( + NullableInt16uAttributeCallback callback + ) { readNullableInt16uAttribute(chipClusterPtr, callback); } - public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt16uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt16uAttribute( - NullableInt16uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt16uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt24uAttribute(NullableInt24uAttributeCallback callback) { + public void readNullableInt24uAttribute( + NullableInt24uAttributeCallback callback + ) { readNullableInt24uAttribute(chipClusterPtr, callback); } - public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt24uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt24uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt24uAttribute( - NullableInt24uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt24uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt32uAttribute(NullableInt32uAttributeCallback callback) { + public void readNullableInt32uAttribute( + NullableInt32uAttributeCallback callback + ) { readNullableInt32uAttribute(chipClusterPtr, callback); } - public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt32uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt32uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt32uAttribute( - NullableInt32uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt32uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt40uAttribute(NullableInt40uAttributeCallback callback) { + public void readNullableInt40uAttribute( + NullableInt40uAttributeCallback callback + ) { readNullableInt40uAttribute(chipClusterPtr, callback); } - public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt40uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt40uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt40uAttribute( - NullableInt40uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt40uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt48uAttribute(NullableInt48uAttributeCallback callback) { + public void readNullableInt48uAttribute( + NullableInt48uAttributeCallback callback + ) { readNullableInt48uAttribute(chipClusterPtr, callback); } - public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt48uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt48uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt48uAttribute( - NullableInt48uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt48uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt56uAttribute(NullableInt56uAttributeCallback callback) { + public void readNullableInt56uAttribute( + NullableInt56uAttributeCallback callback + ) { readNullableInt56uAttribute(chipClusterPtr, callback); } - public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt56uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt56uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt56uAttribute( - NullableInt56uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt56uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt64uAttribute(NullableInt64uAttributeCallback callback) { + public void readNullableInt64uAttribute( + NullableInt64uAttributeCallback callback + ) { readNullableInt64uAttribute(chipClusterPtr, callback); } - public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt64uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt64uAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt64uAttribute( - NullableInt64uAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt64uAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt8sAttribute(NullableInt8sAttributeCallback callback) { + public void readNullableInt8sAttribute( + NullableInt8sAttributeCallback callback + ) { readNullableInt8sAttribute(chipClusterPtr, callback); } - public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt8sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt8sAttribute( - NullableInt8sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt8sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt16sAttribute(NullableInt16sAttributeCallback callback) { + public void readNullableInt16sAttribute( + NullableInt16sAttributeCallback callback + ) { readNullableInt16sAttribute(chipClusterPtr, callback); } - public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt16sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt16sAttribute( - NullableInt16sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt16sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt24sAttribute(NullableInt24sAttributeCallback callback) { + public void readNullableInt24sAttribute( + NullableInt24sAttributeCallback callback + ) { readNullableInt24sAttribute(chipClusterPtr, callback); } - public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt24sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt24sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt24sAttribute( - NullableInt24sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt24sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt32sAttribute(NullableInt32sAttributeCallback callback) { + public void readNullableInt32sAttribute( + NullableInt32sAttributeCallback callback + ) { readNullableInt32sAttribute(chipClusterPtr, callback); } - public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt32sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt32sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt32sAttribute( - NullableInt32sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt32sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt40sAttribute(NullableInt40sAttributeCallback callback) { + public void readNullableInt40sAttribute( + NullableInt40sAttributeCallback callback + ) { readNullableInt40sAttribute(chipClusterPtr, callback); } - public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt40sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt40sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt40sAttribute( - NullableInt40sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt40sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt48sAttribute(NullableInt48sAttributeCallback callback) { + public void readNullableInt48sAttribute( + NullableInt48sAttributeCallback callback + ) { readNullableInt48sAttribute(chipClusterPtr, callback); } - public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt48sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt48sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt48sAttribute( - NullableInt48sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt48sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt56sAttribute(NullableInt56sAttributeCallback callback) { + public void readNullableInt56sAttribute( + NullableInt56sAttributeCallback callback + ) { readNullableInt56sAttribute(chipClusterPtr, callback); } - public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt56sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt56sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt56sAttribute( - NullableInt56sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt56sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt64sAttribute(NullableInt64sAttributeCallback callback) { + public void readNullableInt64sAttribute( + NullableInt64sAttributeCallback callback + ) { readNullableInt64sAttribute(chipClusterPtr, callback); } - public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt64sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt64sAttribute( - DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableInt64sAttribute( - NullableInt64sAttributeCallback callback, int minInterval, int maxInterval) { + NullableInt64sAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnum8Attribute(NullableEnum8AttributeCallback callback) { + public void readNullableEnum8Attribute( + NullableEnum8AttributeCallback callback + ) { readNullableEnum8Attribute(chipClusterPtr, callback); } - public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value) { writeNullableEnum8Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnum8Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableEnum8Attribute( - NullableEnum8AttributeCallback callback, int minInterval, int maxInterval) { + NullableEnum8AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnum16Attribute(NullableEnum16AttributeCallback callback) { + public void readNullableEnum16Attribute( + NullableEnum16AttributeCallback callback + ) { readNullableEnum16Attribute(chipClusterPtr, callback); } - public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value) { writeNullableEnum16Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnum16Attribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableEnum16Attribute( - NullableEnum16AttributeCallback callback, int minInterval, int maxInterval) { + NullableEnum16AttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableFloatSingleAttribute(NullableFloatSingleAttributeCallback callback) { + public void readNullableFloatSingleAttribute( + NullableFloatSingleAttributeCallback callback + ) { readNullableFloatSingleAttribute(chipClusterPtr, callback); } - public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value) { writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableFloatSingleAttribute( - DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableFloatSingleAttribute( - NullableFloatSingleAttributeCallback callback, int minInterval, int maxInterval) { + NullableFloatSingleAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableFloatDoubleAttribute(NullableFloatDoubleAttributeCallback callback) { + public void readNullableFloatDoubleAttribute( + NullableFloatDoubleAttributeCallback callback + ) { readNullableFloatDoubleAttribute(chipClusterPtr, callback); } - public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableFloatDoubleAttribute( - DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableFloatDoubleAttribute( - NullableFloatDoubleAttributeCallback callback, int minInterval, int maxInterval) { + NullableFloatDoubleAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableOctetStringAttribute(NullableOctetStringAttributeCallback callback) { + public void readNullableOctetStringAttribute( + NullableOctetStringAttributeCallback callback + ) { readNullableOctetStringAttribute(chipClusterPtr, callback); } - public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeNullableOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableOctetStringAttribute( - DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeNullableOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableOctetStringAttribute( - NullableOctetStringAttributeCallback callback, int minInterval, int maxInterval) { + NullableOctetStringAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableCharStringAttribute(NullableCharStringAttributeCallback callback) { + public void readNullableCharStringAttribute( + NullableCharStringAttributeCallback callback + ) { readNullableCharStringAttribute(chipClusterPtr, callback); } - public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value) { writeNullableCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableCharStringAttribute( - DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeNullableCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableCharStringAttribute( - NullableCharStringAttributeCallback callback, int minInterval, int maxInterval) { + NullableCharStringAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnumAttrAttribute(NullableEnumAttrAttributeCallback callback) { + public void readNullableEnumAttrAttribute( + NullableEnumAttrAttributeCallback callback + ) { readNullableEnumAttrAttribute(chipClusterPtr, callback); } - public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnumAttrAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableEnumAttrAttribute( - NullableEnumAttrAttributeCallback callback, int minInterval, int maxInterval) { + NullableEnumAttrAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNullableEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt8uAttribute( - NullableRangeRestrictedInt8uAttributeCallback callback) { + NullableRangeRestrictedInt8uAttributeCallback callback + ) { readNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback); } - - public void writeNullableRangeRestrictedInt8uAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt8uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt8uAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableRangeRestrictedInt8uAttribute( - NullableRangeRestrictedInt8uAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt8uAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt8uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt8sAttribute( - NullableRangeRestrictedInt8sAttributeCallback callback) { + NullableRangeRestrictedInt8sAttributeCallback callback + ) { readNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback); } - - public void writeNullableRangeRestrictedInt8sAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt8sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt8sAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableRangeRestrictedInt8sAttribute( - NullableRangeRestrictedInt8sAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt8sAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt8sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt16uAttribute( - NullableRangeRestrictedInt16uAttributeCallback callback) { + NullableRangeRestrictedInt16uAttributeCallback callback + ) { readNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback); } - - public void writeNullableRangeRestrictedInt16uAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt16uAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt16uAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableRangeRestrictedInt16uAttribute( - NullableRangeRestrictedInt16uAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt16uAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt16uAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt16sAttribute( - NullableRangeRestrictedInt16sAttributeCallback callback) { + NullableRangeRestrictedInt16sAttributeCallback callback + ) { readNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback); } - - public void writeNullableRangeRestrictedInt16sAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt16sAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt16sAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeNullableRangeRestrictedInt16sAttribute( - NullableRangeRestrictedInt16sAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt16sAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt16sAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeBooleanAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBitmap8Attribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeBitmap8Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBitmap8Attribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBitmap16Attribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeBitmap16Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBitmap16Attribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBitmap32Attribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeBitmap32Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBitmap32Attribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBitmap64Attribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeBitmap64Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeBitmap64Attribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt8uAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeInt8uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt8uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt16uAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeInt16uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt16uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt24uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt24uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt24uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt32uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt32uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt32uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt40uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt40uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt40uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt48uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt48uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt48uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt56uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt56uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt56uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt64uAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt64uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt64uAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt8sAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeInt8sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt8sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt16sAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeInt16sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt16sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt24sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt24sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt24sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt32sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt32sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt32sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt40sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt40sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt40sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt48sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt48sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt48sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt56sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt56sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt56sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInt64sAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeInt64sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeInt64sAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnum8Attribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeEnum8Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEnum8Attribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEnum16Attribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeEnum16Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEnum16Attribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readFloatSingleAttribute( - long chipClusterPtr, FloatAttributeCallback callback); - - private native void writeFloatSingleAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Float value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeFloatSingleAttribute( - long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval); - - private native void readFloatDoubleAttribute( - long chipClusterPtr, DoubleAttributeCallback callback); - - private native void writeFloatDoubleAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Double value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeFloatDoubleAttribute( - long chipClusterPtr, DoubleAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOctetStringAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void writeOctetStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - byte[] value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOctetStringAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readListInt8uAttribute( - long chipClusterPtr, ListInt8uAttributeCallback callback); - - private native void writeListInt8uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeListInt8uAttribute( - long chipClusterPtr, ListInt8uAttributeCallback callback, int minInterval, int maxInterval); - - private native void readListOctetStringAttribute( - long chipClusterPtr, ListOctetStringAttributeCallback callback); - - private native void writeListOctetStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeListOctetStringAttribute( - long chipClusterPtr, - ListOctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readListStructOctetStringAttribute( - long chipClusterPtr, ListStructOctetStringAttributeCallback callback); - - private native void writeListStructOctetStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeListStructOctetStringAttribute( - long chipClusterPtr, - ListStructOctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readLongOctetStringAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void writeLongOctetStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - byte[] value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLongOctetStringAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCharStringAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeCharStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeCharStringAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readLongCharStringAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void writeLongCharStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLongCharStringAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readEpochUsAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeEpochUsAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEpochUsAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readEpochSAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void writeEpochSAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEpochSAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readVendorIdAttribute( - long chipClusterPtr, VendorIdAttributeCallback callback); - - private native void writeVendorIdAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeVendorIdAttribute( - long chipClusterPtr, VendorIdAttributeCallback callback, int minInterval, int maxInterval); - - private native void readListNullablesAndOptionalsStructAttribute( - long chipClusterPtr, ListNullablesAndOptionalsStructAttributeCallback callback); - - private native void writeListNullablesAndOptionalsStructAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeListNullablesAndOptionalsStructAttribute( - long chipClusterPtr, - ListNullablesAndOptionalsStructAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readEnumAttrAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeEnumAttrAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeEnumAttrAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt8uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeRangeRestrictedInt8uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeRangeRestrictedInt8uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt8sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeRangeRestrictedInt8sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeRangeRestrictedInt8sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt16uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeRangeRestrictedInt16uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeRangeRestrictedInt16uAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt16sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeRangeRestrictedInt16sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeRangeRestrictedInt16sAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readListLongOctetStringAttribute( - long chipClusterPtr, ListLongOctetStringAttributeCallback callback); - - private native void subscribeListLongOctetStringAttribute( - long chipClusterPtr, - ListLongOctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readTimedWriteBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeTimedWriteBooleanAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeTimedWriteBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readGeneralErrorBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeGeneralErrorBooleanAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeGeneralErrorBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readClusterErrorBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeClusterErrorBooleanAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeClusterErrorBooleanAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readUnsupportedAttribute( - long chipClusterPtr, BooleanAttributeCallback callback); - - private native void writeUnsupportedAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeUnsupportedAttribute( - long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNullableBooleanAttribute( - long chipClusterPtr, NullableBooleanAttributeCallback callback); - - private native void writeNullableBooleanAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Boolean value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableBooleanAttribute( - long chipClusterPtr, - NullableBooleanAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableBitmap8Attribute( - long chipClusterPtr, NullableBitmap8AttributeCallback callback); - - private native void writeNullableBitmap8Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableBitmap8Attribute( - long chipClusterPtr, - NullableBitmap8AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableBitmap16Attribute( - long chipClusterPtr, NullableBitmap16AttributeCallback callback); - - private native void writeNullableBitmap16Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableBitmap16Attribute( - long chipClusterPtr, - NullableBitmap16AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableBitmap32Attribute( - long chipClusterPtr, NullableBitmap32AttributeCallback callback); - - private native void writeNullableBitmap32Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableBitmap32Attribute( - long chipClusterPtr, - NullableBitmap32AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableBitmap64Attribute( - long chipClusterPtr, NullableBitmap64AttributeCallback callback); - - private native void writeNullableBitmap64Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableBitmap64Attribute( - long chipClusterPtr, - NullableBitmap64AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt8uAttribute( - long chipClusterPtr, NullableInt8uAttributeCallback callback); - - private native void writeNullableInt8uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt8uAttribute( - long chipClusterPtr, - NullableInt8uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt16uAttribute( - long chipClusterPtr, NullableInt16uAttributeCallback callback); - - private native void writeNullableInt16uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt16uAttribute( - long chipClusterPtr, - NullableInt16uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt24uAttribute( - long chipClusterPtr, NullableInt24uAttributeCallback callback); - - private native void writeNullableInt24uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt24uAttribute( - long chipClusterPtr, - NullableInt24uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt32uAttribute( - long chipClusterPtr, NullableInt32uAttributeCallback callback); - - private native void writeNullableInt32uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt32uAttribute( - long chipClusterPtr, - NullableInt32uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt40uAttribute( - long chipClusterPtr, NullableInt40uAttributeCallback callback); - - private native void writeNullableInt40uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt40uAttribute( - long chipClusterPtr, - NullableInt40uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt48uAttribute( - long chipClusterPtr, NullableInt48uAttributeCallback callback); - - private native void writeNullableInt48uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt48uAttribute( - long chipClusterPtr, - NullableInt48uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt56uAttribute( - long chipClusterPtr, NullableInt56uAttributeCallback callback); - - private native void writeNullableInt56uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt56uAttribute( - long chipClusterPtr, - NullableInt56uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt64uAttribute( - long chipClusterPtr, NullableInt64uAttributeCallback callback); - - private native void writeNullableInt64uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt64uAttribute( - long chipClusterPtr, - NullableInt64uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt8sAttribute( - long chipClusterPtr, NullableInt8sAttributeCallback callback); - - private native void writeNullableInt8sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt8sAttribute( - long chipClusterPtr, - NullableInt8sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt16sAttribute( - long chipClusterPtr, NullableInt16sAttributeCallback callback); - - private native void writeNullableInt16sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt16sAttribute( - long chipClusterPtr, - NullableInt16sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt24sAttribute( - long chipClusterPtr, NullableInt24sAttributeCallback callback); - - private native void writeNullableInt24sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt24sAttribute( - long chipClusterPtr, - NullableInt24sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt32sAttribute( - long chipClusterPtr, NullableInt32sAttributeCallback callback); - - private native void writeNullableInt32sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt32sAttribute( - long chipClusterPtr, - NullableInt32sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt40sAttribute( - long chipClusterPtr, NullableInt40sAttributeCallback callback); - - private native void writeNullableInt40sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt40sAttribute( - long chipClusterPtr, - NullableInt40sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt48sAttribute( - long chipClusterPtr, NullableInt48sAttributeCallback callback); - - private native void writeNullableInt48sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt48sAttribute( - long chipClusterPtr, - NullableInt48sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt56sAttribute( - long chipClusterPtr, NullableInt56sAttributeCallback callback); - - private native void writeNullableInt56sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt56sAttribute( - long chipClusterPtr, - NullableInt56sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableInt64sAttribute( - long chipClusterPtr, NullableInt64sAttributeCallback callback); - - private native void writeNullableInt64sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Long value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableInt64sAttribute( - long chipClusterPtr, - NullableInt64sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableEnum8Attribute( - long chipClusterPtr, NullableEnum8AttributeCallback callback); - - private native void writeNullableEnum8Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableEnum8Attribute( - long chipClusterPtr, - NullableEnum8AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableEnum16Attribute( - long chipClusterPtr, NullableEnum16AttributeCallback callback); - - private native void writeNullableEnum16Attribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableEnum16Attribute( - long chipClusterPtr, - NullableEnum16AttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableFloatSingleAttribute( - long chipClusterPtr, NullableFloatSingleAttributeCallback callback); - - private native void writeNullableFloatSingleAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Float value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableFloatSingleAttribute( - long chipClusterPtr, - NullableFloatSingleAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableFloatDoubleAttribute( - long chipClusterPtr, NullableFloatDoubleAttributeCallback callback); - - private native void writeNullableFloatDoubleAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Double value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableFloatDoubleAttribute( - long chipClusterPtr, - NullableFloatDoubleAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableOctetStringAttribute( - long chipClusterPtr, NullableOctetStringAttributeCallback callback); - - private native void writeNullableOctetStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - byte[] value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableOctetStringAttribute( - long chipClusterPtr, - NullableOctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableCharStringAttribute( - long chipClusterPtr, NullableCharStringAttributeCallback callback); - - private native void writeNullableCharStringAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - String value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableCharStringAttribute( - long chipClusterPtr, - NullableCharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableEnumAttrAttribute( - long chipClusterPtr, NullableEnumAttrAttributeCallback callback); - - private native void writeNullableEnumAttrAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableEnumAttrAttribute( - long chipClusterPtr, - NullableEnumAttrAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableRangeRestrictedInt8uAttribute( - long chipClusterPtr, NullableRangeRestrictedInt8uAttributeCallback callback); - - private native void writeNullableRangeRestrictedInt8uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableRangeRestrictedInt8uAttribute( - long chipClusterPtr, - NullableRangeRestrictedInt8uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableRangeRestrictedInt8sAttribute( - long chipClusterPtr, NullableRangeRestrictedInt8sAttributeCallback callback); - - private native void writeNullableRangeRestrictedInt8sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableRangeRestrictedInt8sAttribute( - long chipClusterPtr, - NullableRangeRestrictedInt8sAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableRangeRestrictedInt16uAttribute( - long chipClusterPtr, NullableRangeRestrictedInt16uAttributeCallback callback); - - private native void writeNullableRangeRestrictedInt16uAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableRangeRestrictedInt16uAttribute( - long chipClusterPtr, - NullableRangeRestrictedInt16uAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readNullableRangeRestrictedInt16sAttribute( - long chipClusterPtr, NullableRangeRestrictedInt16sAttributeCallback callback); - - private native void writeNullableRangeRestrictedInt16sAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeNullableRangeRestrictedInt16sAttribute( - long chipClusterPtr, - NullableRangeRestrictedInt16sAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap32Attribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap32Attribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBitmap64Attribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeBitmap64Attribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt24uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt24uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt32uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt32uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt40uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt40uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt48uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt48uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt56uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt56uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt64uAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt64uAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt24sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt24sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt32sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt32sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt40sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt40sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt48sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt48sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt56sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt56sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInt64sAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeInt64sAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnum8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnum8Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEnum16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnum16Attribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readFloatSingleAttribute(long chipClusterPtr, + FloatAttributeCallback callback + ); + + private native void writeFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeFloatSingleAttribute(long chipClusterPtr, + FloatAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readFloatDoubleAttribute(long chipClusterPtr, + DoubleAttributeCallback callback + ); + + private native void writeFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeFloatDoubleAttribute(long chipClusterPtr, + DoubleAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + + private native void writeOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readListInt8uAttribute(long chipClusterPtr, + ListInt8uAttributeCallback callback + ); + + private native void writeListInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListInt8uAttribute(long chipClusterPtr, + ListInt8uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readListOctetStringAttribute(long chipClusterPtr, + ListOctetStringAttributeCallback callback + ); + + private native void writeListOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListOctetStringAttribute(long chipClusterPtr, + ListOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readListStructOctetStringAttribute(long chipClusterPtr, + ListStructOctetStringAttributeCallback callback + ); + + private native void writeListStructOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListStructOctetStringAttribute(long chipClusterPtr, + ListStructOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readLongOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + + private native void writeLongOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLongOctetStringAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLongCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + + private native void writeLongCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLongCharStringAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEpochUsAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeEpochUsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEpochUsAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readEpochSAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + + private native void writeEpochSAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEpochSAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readVendorIdAttribute(long chipClusterPtr, + VendorIdAttributeCallback callback + ); + + private native void writeVendorIdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeVendorIdAttribute(long chipClusterPtr, + VendorIdAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readListNullablesAndOptionalsStructAttribute(long chipClusterPtr, + ListNullablesAndOptionalsStructAttributeCallback callback + ); + + private native void writeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, + ListNullablesAndOptionalsStructAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEnumAttrAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeEnumAttrAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt8uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt8sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt16uAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeRangeRestrictedInt16sAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readListLongOctetStringAttribute(long chipClusterPtr, + ListLongOctetStringAttributeCallback callback + ); + private native void subscribeListLongOctetStringAttribute(long chipClusterPtr, + ListLongOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTimedWriteBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeTimedWriteBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeTimedWriteBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readGeneralErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeGeneralErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeGeneralErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readClusterErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeClusterErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeClusterErrorBooleanAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readUnsupportedAttribute(long chipClusterPtr, + BooleanAttributeCallback callback + ); + + private native void writeUnsupportedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeUnsupportedAttribute(long chipClusterPtr, + BooleanAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNullableBooleanAttribute(long chipClusterPtr, + NullableBooleanAttributeCallback callback + ); + + private native void writeNullableBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBooleanAttribute(long chipClusterPtr, + NullableBooleanAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap8Attribute(long chipClusterPtr, + NullableBitmap8AttributeCallback callback + ); + + private native void writeNullableBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap8Attribute(long chipClusterPtr, + NullableBitmap8AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap16Attribute(long chipClusterPtr, + NullableBitmap16AttributeCallback callback + ); + + private native void writeNullableBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap16Attribute(long chipClusterPtr, + NullableBitmap16AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap32Attribute(long chipClusterPtr, + NullableBitmap32AttributeCallback callback + ); + + private native void writeNullableBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap32Attribute(long chipClusterPtr, + NullableBitmap32AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableBitmap64Attribute(long chipClusterPtr, + NullableBitmap64AttributeCallback callback + ); + + private native void writeNullableBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableBitmap64Attribute(long chipClusterPtr, + NullableBitmap64AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt8uAttribute(long chipClusterPtr, + NullableInt8uAttributeCallback callback + ); + + private native void writeNullableInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt8uAttribute(long chipClusterPtr, + NullableInt8uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt16uAttribute(long chipClusterPtr, + NullableInt16uAttributeCallback callback + ); + + private native void writeNullableInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt16uAttribute(long chipClusterPtr, + NullableInt16uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt24uAttribute(long chipClusterPtr, + NullableInt24uAttributeCallback callback + ); + + private native void writeNullableInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt24uAttribute(long chipClusterPtr, + NullableInt24uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt32uAttribute(long chipClusterPtr, + NullableInt32uAttributeCallback callback + ); + + private native void writeNullableInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt32uAttribute(long chipClusterPtr, + NullableInt32uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt40uAttribute(long chipClusterPtr, + NullableInt40uAttributeCallback callback + ); + + private native void writeNullableInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt40uAttribute(long chipClusterPtr, + NullableInt40uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt48uAttribute(long chipClusterPtr, + NullableInt48uAttributeCallback callback + ); + + private native void writeNullableInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt48uAttribute(long chipClusterPtr, + NullableInt48uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt56uAttribute(long chipClusterPtr, + NullableInt56uAttributeCallback callback + ); + + private native void writeNullableInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt56uAttribute(long chipClusterPtr, + NullableInt56uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt64uAttribute(long chipClusterPtr, + NullableInt64uAttributeCallback callback + ); + + private native void writeNullableInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt64uAttribute(long chipClusterPtr, + NullableInt64uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt8sAttribute(long chipClusterPtr, + NullableInt8sAttributeCallback callback + ); + + private native void writeNullableInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt8sAttribute(long chipClusterPtr, + NullableInt8sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt16sAttribute(long chipClusterPtr, + NullableInt16sAttributeCallback callback + ); + + private native void writeNullableInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt16sAttribute(long chipClusterPtr, + NullableInt16sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt24sAttribute(long chipClusterPtr, + NullableInt24sAttributeCallback callback + ); + + private native void writeNullableInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt24sAttribute(long chipClusterPtr, + NullableInt24sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt32sAttribute(long chipClusterPtr, + NullableInt32sAttributeCallback callback + ); + + private native void writeNullableInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt32sAttribute(long chipClusterPtr, + NullableInt32sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt40sAttribute(long chipClusterPtr, + NullableInt40sAttributeCallback callback + ); + + private native void writeNullableInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt40sAttribute(long chipClusterPtr, + NullableInt40sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt48sAttribute(long chipClusterPtr, + NullableInt48sAttributeCallback callback + ); + + private native void writeNullableInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt48sAttribute(long chipClusterPtr, + NullableInt48sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt56sAttribute(long chipClusterPtr, + NullableInt56sAttributeCallback callback + ); + + private native void writeNullableInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt56sAttribute(long chipClusterPtr, + NullableInt56sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableInt64sAttribute(long chipClusterPtr, + NullableInt64sAttributeCallback callback + ); + + private native void writeNullableInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableInt64sAttribute(long chipClusterPtr, + NullableInt64sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableEnum8Attribute(long chipClusterPtr, + NullableEnum8AttributeCallback callback + ); + + private native void writeNullableEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableEnum8Attribute(long chipClusterPtr, + NullableEnum8AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableEnum16Attribute(long chipClusterPtr, + NullableEnum16AttributeCallback callback + ); + + private native void writeNullableEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableEnum16Attribute(long chipClusterPtr, + NullableEnum16AttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableFloatSingleAttribute(long chipClusterPtr, + NullableFloatSingleAttributeCallback callback + ); + + private native void writeNullableFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableFloatSingleAttribute(long chipClusterPtr, + NullableFloatSingleAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableFloatDoubleAttribute(long chipClusterPtr, + NullableFloatDoubleAttributeCallback callback + ); + + private native void writeNullableFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableFloatDoubleAttribute(long chipClusterPtr, + NullableFloatDoubleAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableOctetStringAttribute(long chipClusterPtr, + NullableOctetStringAttributeCallback callback + ); + + private native void writeNullableOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableOctetStringAttribute(long chipClusterPtr, + NullableOctetStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableCharStringAttribute(long chipClusterPtr, + NullableCharStringAttributeCallback callback + ); + + private native void writeNullableCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableCharStringAttribute(long chipClusterPtr, + NullableCharStringAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableEnumAttrAttribute(long chipClusterPtr, + NullableEnumAttrAttributeCallback callback + ); + + private native void writeNullableEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableEnumAttrAttribute(long chipClusterPtr, + NullableEnumAttrAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8uAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8sAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt8sAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16uAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16uAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16sAttributeCallback callback + ); + + private native void writeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, + NullableRangeRestrictedInt16sAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class ThermostatCluster extends BaseChipCluster { @@ -15440,587 +14214,554 @@ public ThermostatCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void clearWeeklySchedule(DefaultClusterCallback callback) { + public void clearWeeklySchedule(DefaultClusterCallback callback + ) { clearWeeklySchedule(chipClusterPtr, callback, null); } - public void clearWeeklySchedule(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void clearWeeklySchedule(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { clearWeeklySchedule(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback) { + public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback + ) { getRelayStatusLog(chipClusterPtr, callback, null); } - public void getRelayStatusLog( - GetRelayStatusLogResponseCallback callback, int timedInvokeTimeoutMs) { - + public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback + + , int timedInvokeTimeoutMs) { getRelayStatusLog(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void getWeeklySchedule( - GetWeeklyScheduleResponseCallback callback, Integer daysToReturn, Integer modeToReturn) { + public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback + , Integer daysToReturn, Integer modeToReturn) { getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, null); } - public void getWeeklySchedule( - GetWeeklyScheduleResponseCallback callback, - Integer daysToReturn, - Integer modeToReturn, - int timedInvokeTimeoutMs) { + public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback + , Integer daysToReturn, Integer modeToReturn + , int timedInvokeTimeoutMs) { getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, timedInvokeTimeoutMs); } - public void setWeeklySchedule( - DefaultClusterCallback callback, - Integer numberOfTransitionsForSequence, - Integer dayOfWeekForSequence, - Integer modeForSequence, - ArrayList payload) { - setWeeklySchedule( - chipClusterPtr, - callback, - numberOfTransitionsForSequence, - dayOfWeekForSequence, - modeForSequence, - payload, - null); - } - - public void setWeeklySchedule( - DefaultClusterCallback callback, - Integer numberOfTransitionsForSequence, - Integer dayOfWeekForSequence, - Integer modeForSequence, - ArrayList payload, - int timedInvokeTimeoutMs) { - setWeeklySchedule( - chipClusterPtr, - callback, - numberOfTransitionsForSequence, - dayOfWeekForSequence, - modeForSequence, - payload, - timedInvokeTimeoutMs); - } - - public void setpointRaiseLower(DefaultClusterCallback callback, Integer mode, Integer amount) { - setpointRaiseLower(chipClusterPtr, callback, mode, amount, null); + public void setWeeklySchedule(DefaultClusterCallback callback + , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload) { + setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, payload, null); } - public void setpointRaiseLower( - DefaultClusterCallback callback, Integer mode, Integer amount, int timedInvokeTimeoutMs) { - setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs); + public void setWeeklySchedule(DefaultClusterCallback callback + , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload + , int timedInvokeTimeoutMs) { + setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, payload, timedInvokeTimeoutMs); } - private native void clearWeeklySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getRelayStatusLog( - long chipClusterPtr, - GetRelayStatusLogResponseCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void getWeeklySchedule( - long chipClusterPtr, - GetWeeklyScheduleResponseCallback Callback, - Integer daysToReturn, - Integer modeToReturn, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setWeeklySchedule( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer numberOfTransitionsForSequence, - Integer dayOfWeekForSequence, - Integer modeForSequence, - ArrayList payload, - @Nullable Integer timedInvokeTimeoutMs); - - private native void setpointRaiseLower( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer mode, - Integer amount, - @Nullable Integer timedInvokeTimeoutMs); + public void setpointRaiseLower(DefaultClusterCallback callback + , Integer mode, Integer amount) { + setpointRaiseLower(chipClusterPtr, callback, mode, amount, null); + } + public void setpointRaiseLower(DefaultClusterCallback callback + , Integer mode, Integer amount + , int timedInvokeTimeoutMs) { + setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs); + } + private native void clearWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void getRelayStatusLog(long chipClusterPtr, GetRelayStatusLogResponseCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void getWeeklySchedule(long chipClusterPtr, GetWeeklyScheduleResponseCallback Callback + , Integer daysToReturn, Integer modeToReturn + , @Nullable Integer timedInvokeTimeoutMs); + private native void setWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback + , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload + , @Nullable Integer timedInvokeTimeoutMs); + private native void setpointRaiseLower(long chipClusterPtr, DefaultClusterCallback Callback + , Integer mode, Integer amount + , @Nullable Integer timedInvokeTimeoutMs); public interface GetRelayStatusLogResponseCallback { - void onSuccess( - Integer timeOfDay, - Integer relayStatus, - Integer localTemperature, - Integer humidityInPercentage, - Integer setpoint, - Integer unreadEntries); - + void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries); + void onError(Exception error); } public interface GetWeeklyScheduleResponseCallback { - void onSuccess( - Integer numberOfTransitionsForSequence, - Integer dayOfWeekForSequence, - Integer modeForSequence, - ArrayList payload); - + void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload); + void onError(Exception error); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readLocalTemperatureAttribute(IntegerAttributeCallback callback) { + public void readLocalTemperatureAttribute( + IntegerAttributeCallback callback + ) { readLocalTemperatureAttribute(chipClusterPtr, callback); } - public void subscribeLocalTemperatureAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLocalTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMinHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readAbsMinHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback); } - public void subscribeAbsMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMaxHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readAbsMaxHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); } - public void subscribeAbsMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMinCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readAbsMinCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback); } - public void subscribeAbsMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMaxCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readAbsMaxCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); } - public void subscribeAbsMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupiedCoolingSetpointAttribute(IntegerAttributeCallback callback) { + public void readOccupiedCoolingSetpointAttribute( + IntegerAttributeCallback callback + ) { readOccupiedCoolingSetpointAttribute(chipClusterPtr, callback); } - - public void writeOccupiedCoolingSetpointAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value) { writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, null); } - public void writeOccupiedCoolingSetpointAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOccupiedCoolingSetpointAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupiedHeatingSetpointAttribute(IntegerAttributeCallback callback) { + public void readOccupiedHeatingSetpointAttribute( + IntegerAttributeCallback callback + ) { readOccupiedHeatingSetpointAttribute(chipClusterPtr, callback); } - - public void writeOccupiedHeatingSetpointAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value) { writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, null); } - public void writeOccupiedHeatingSetpointAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeOccupiedHeatingSetpointAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readMinHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readMinHeatSetpointLimitAttribute(chipClusterPtr, callback); } - public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMinHeatSetpointLimitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readMaxHeatSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); } - public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMaxHeatSetpointLimitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readMinCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readMinCoolSetpointLimitAttribute(chipClusterPtr, callback); } - public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMinCoolSetpointLimitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { + public void readMaxCoolSetpointLimitAttribute( + IntegerAttributeCallback callback + ) { readMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); } - public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMaxCoolSetpointLimitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinSetpointDeadBandAttribute(IntegerAttributeCallback callback) { + public void readMinSetpointDeadBandAttribute( + IntegerAttributeCallback callback + ) { readMinSetpointDeadBandAttribute(chipClusterPtr, callback); } - public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value) { writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, null); } - public void writeMinSetpointDeadBandAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeMinSetpointDeadBandAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMinSetpointDeadBandAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readControlSequenceOfOperationAttribute(IntegerAttributeCallback callback) { + public void readControlSequenceOfOperationAttribute( + IntegerAttributeCallback callback + ) { readControlSequenceOfOperationAttribute(chipClusterPtr, callback); } - - public void writeControlSequenceOfOperationAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value) { writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, null); } - public void writeControlSequenceOfOperationAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeControlSequenceOfOperationAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeControlSequenceOfOperationAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeControlSequenceOfOperationAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeControlSequenceOfOperationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSystemModeAttribute(IntegerAttributeCallback callback) { + public void readSystemModeAttribute( + IntegerAttributeCallback callback + ) { readSystemModeAttribute(chipClusterPtr, callback); } - public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value) { writeSystemModeAttribute(chipClusterPtr, callback, value, null); } - public void writeSystemModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSystemModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeSystemModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSystemModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartOfWeekAttribute(IntegerAttributeCallback callback) { + public void readStartOfWeekAttribute( + IntegerAttributeCallback callback + ) { readStartOfWeekAttribute(chipClusterPtr, callback); } - public void subscribeStartOfWeekAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStartOfWeekAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfWeeklyTransitionsAttribute(IntegerAttributeCallback callback) { + public void readNumberOfWeeklyTransitionsAttribute( + IntegerAttributeCallback callback + ) { readNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfWeeklyTransitionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfWeeklyTransitionsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfDailyTransitionsAttribute(IntegerAttributeCallback callback) { + public void readNumberOfDailyTransitionsAttribute( + IntegerAttributeCallback callback + ) { readNumberOfDailyTransitionsAttribute(chipClusterPtr, callback); } - public void subscribeNumberOfDailyTransitionsAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeNumberOfDailyTransitionsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeNumberOfDailyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLocalTemperatureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLocalTemperatureAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAbsMinHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAbsMinHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAbsMaxHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAbsMaxHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAbsMinCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAbsMinCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAbsMaxCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAbsMaxCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOccupiedCoolingSetpointAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOccupiedCoolingSetpointAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOccupiedCoolingSetpointAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOccupiedHeatingSetpointAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeOccupiedHeatingSetpointAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeOccupiedHeatingSetpointAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeMinHeatSetpointLimitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeMinHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeMaxHeatSetpointLimitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeMaxHeatSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeMinCoolSetpointLimitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeMinCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMaxCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeMaxCoolSetpointLimitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeMaxCoolSetpointLimitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMinSetpointDeadBandAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeMinSetpointDeadBandAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeMinSetpointDeadBandAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readControlSequenceOfOperationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeControlSequenceOfOperationAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeControlSequenceOfOperationAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSystemModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeSystemModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeSystemModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStartOfWeekAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeStartOfWeekAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfWeeklyTransitionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfWeeklyTransitionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNumberOfDailyTransitionsAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeNumberOfDailyTransitionsAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readLocalTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLocalTemperatureAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupiedCoolingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOccupiedCoolingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOccupiedCoolingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOccupiedHeatingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeOccupiedHeatingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeOccupiedHeatingSetpointAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMinHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMinHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMaxHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMaxHeatSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMinCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMinCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMaxCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMaxCoolSetpointLimitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMinSetpointDeadBandAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeMinSetpointDeadBandAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeMinSetpointDeadBandAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readControlSequenceOfOperationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeControlSequenceOfOperationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeControlSequenceOfOperationAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSystemModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeSystemModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeSystemModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStartOfWeekAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStartOfWeekAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNumberOfDailyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeNumberOfDailyTransitionsAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 ThermostatUserInterfaceConfigurationCluster extends BaseChipCluster { @@ -16033,1237 +14774,1443 @@ public ThermostatUserInterfaceConfigurationCluster(long devicePtr, int endpointI @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readTemperatureDisplayModeAttribute(IntegerAttributeCallback callback) { + public void readTemperatureDisplayModeAttribute( + IntegerAttributeCallback callback + ) { readTemperatureDisplayModeAttribute(chipClusterPtr, callback); } - - public void writeTemperatureDisplayModeAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value) { writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, null); } - public void writeTemperatureDisplayModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeTemperatureDisplayModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTemperatureDisplayModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readKeypadLockoutAttribute(IntegerAttributeCallback callback) { + public void readKeypadLockoutAttribute( + IntegerAttributeCallback callback + ) { readKeypadLockoutAttribute(chipClusterPtr, callback); } - public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value) { writeKeypadLockoutAttribute(chipClusterPtr, callback, value, null); } - public void writeKeypadLockoutAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeKeypadLockoutAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeKeypadLockoutAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeKeypadLockoutAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readScheduleProgrammingVisibilityAttribute(IntegerAttributeCallback callback) { + public void readScheduleProgrammingVisibilityAttribute( + IntegerAttributeCallback callback + ) { readScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback); } - - public void writeScheduleProgrammingVisibilityAttribute( - DefaultClusterCallback callback, Integer value) { + public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value) { writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, null); } - public void writeScheduleProgrammingVisibilityAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeScheduleProgrammingVisibilityAttribute( - chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeScheduleProgrammingVisibilityAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeScheduleProgrammingVisibilityAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { - subscribeAttributeListAttribute(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 readTemperatureDisplayModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeTemperatureDisplayModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeTemperatureDisplayModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readKeypadLockoutAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeKeypadLockoutAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeKeypadLockoutAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readScheduleProgrammingVisibilityAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeScheduleProgrammingVisibilityAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeScheduleProgrammingVisibilityAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - } - - public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 53L; - - public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } - - @Override - public native long initWithDevice(long devicePtr, int endpointId); - - public void resetCounts(DefaultClusterCallback callback) { - resetCounts(chipClusterPtr, callback, null); - } - - public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - - resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); - } - - private native void resetCounts( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface NeighborTableListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface RouteTableListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public interface SecurityPolicyAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { + readClusterRevisionAttribute(chipClusterPtr, callback); } - - public interface OperationalDatasetComponentsAttributeCallback { - void onSuccess( - List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public interface ActiveNetworkFaultsListAttributeCallback { - void onSuccess(List valueList); + private native void readTemperatureDisplayModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeTemperatureDisplayModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeTemperatureDisplayModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readKeypadLockoutAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeKeypadLockoutAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeKeypadLockoutAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readScheduleProgrammingVisibilityAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + } - void onError(Exception ex); + public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 53L; - default void onSubscriptionEstablished() {} + public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); } - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); + @Override + public native long initWithDevice(long devicePtr, int endpointId); - void onError(Exception ex); + public void resetCounts(DefaultClusterCallback callback + ) { + resetCounts(chipClusterPtr, callback, null); + } - default void onSubscriptionEstablished() {} + public void resetCounts(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { + resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface NeighborTableListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface RouteTableListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface SecurityPolicyAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface OperationalDatasetComponentsAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface ActiveNetworkFaultsListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readChannelAttribute(IntegerAttributeCallback callback) { + public void readChannelAttribute( + IntegerAttributeCallback callback + ) { readChannelAttribute(chipClusterPtr, callback); } - public void subscribeChannelAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeChannelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRoutingRoleAttribute(IntegerAttributeCallback callback) { + public void readRoutingRoleAttribute( + IntegerAttributeCallback callback + ) { readRoutingRoleAttribute(chipClusterPtr, callback); } - public void subscribeRoutingRoleAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRoutingRoleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNetworkNameAttribute(CharStringAttributeCallback callback) { + public void readNetworkNameAttribute( + CharStringAttributeCallback callback + ) { readNetworkNameAttribute(chipClusterPtr, callback); } - public void subscribeNetworkNameAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeNetworkNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPanIdAttribute(IntegerAttributeCallback callback) { + public void readPanIdAttribute( + IntegerAttributeCallback callback + ) { readPanIdAttribute(chipClusterPtr, callback); } - public void subscribePanIdAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readExtendedPanIdAttribute(LongAttributeCallback callback) { + public void readExtendedPanIdAttribute( + LongAttributeCallback callback + ) { readExtendedPanIdAttribute(chipClusterPtr, callback); } - public void subscribeExtendedPanIdAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeExtendedPanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMeshLocalPrefixAttribute(OctetStringAttributeCallback callback) { + public void readMeshLocalPrefixAttribute( + OctetStringAttributeCallback callback + ) { readMeshLocalPrefixAttribute(chipClusterPtr, callback); } - public void subscribeMeshLocalPrefixAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeMeshLocalPrefixAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute(LongAttributeCallback callback) { + public void readOverrunCountAttribute( + LongAttributeCallback callback + ) { readOverrunCountAttribute(chipClusterPtr, callback); } - public void subscribeOverrunCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNeighborTableListAttribute(NeighborTableListAttributeCallback callback) { + public void readNeighborTableListAttribute( + NeighborTableListAttributeCallback callback + ) { readNeighborTableListAttribute(chipClusterPtr, callback); } - public void subscribeNeighborTableListAttribute( - NeighborTableListAttributeCallback callback, int minInterval, int maxInterval) { + NeighborTableListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeNeighborTableListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRouteTableListAttribute(RouteTableListAttributeCallback callback) { + public void readRouteTableListAttribute( + RouteTableListAttributeCallback callback + ) { readRouteTableListAttribute(chipClusterPtr, callback); } - public void subscribeRouteTableListAttribute( - RouteTableListAttributeCallback callback, int minInterval, int maxInterval) { + RouteTableListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeRouteTableListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartitionIdAttribute(LongAttributeCallback callback) { + public void readPartitionIdAttribute( + LongAttributeCallback callback + ) { readPartitionIdAttribute(chipClusterPtr, callback); } - public void subscribePartitionIdAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePartitionIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWeightingAttribute(IntegerAttributeCallback callback) { + public void readWeightingAttribute( + IntegerAttributeCallback callback + ) { readWeightingAttribute(chipClusterPtr, callback); } - public void subscribeWeightingAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWeightingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDataVersionAttribute(IntegerAttributeCallback callback) { + public void readDataVersionAttribute( + IntegerAttributeCallback callback + ) { readDataVersionAttribute(chipClusterPtr, callback); } - public void subscribeDataVersionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStableDataVersionAttribute(IntegerAttributeCallback callback) { + public void readStableDataVersionAttribute( + IntegerAttributeCallback callback + ) { readStableDataVersionAttribute(chipClusterPtr, callback); } - public void subscribeStableDataVersionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeStableDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLeaderRouterIdAttribute(IntegerAttributeCallback callback) { + public void readLeaderRouterIdAttribute( + IntegerAttributeCallback callback + ) { readLeaderRouterIdAttribute(chipClusterPtr, callback); } - public void subscribeLeaderRouterIdAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLeaderRouterIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDetachedRoleCountAttribute(IntegerAttributeCallback callback) { + public void readDetachedRoleCountAttribute( + IntegerAttributeCallback callback + ) { readDetachedRoleCountAttribute(chipClusterPtr, callback); } - public void subscribeDetachedRoleCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDetachedRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readChildRoleCountAttribute(IntegerAttributeCallback callback) { + public void readChildRoleCountAttribute( + IntegerAttributeCallback callback + ) { readChildRoleCountAttribute(chipClusterPtr, callback); } - public void subscribeChildRoleCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeChildRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRouterRoleCountAttribute(IntegerAttributeCallback callback) { + public void readRouterRoleCountAttribute( + IntegerAttributeCallback callback + ) { readRouterRoleCountAttribute(chipClusterPtr, callback); } - public void subscribeRouterRoleCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRouterRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLeaderRoleCountAttribute(IntegerAttributeCallback callback) { + public void readLeaderRoleCountAttribute( + IntegerAttributeCallback callback + ) { readLeaderRoleCountAttribute(chipClusterPtr, callback); } - public void subscribeLeaderRoleCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeLeaderRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttachAttemptCountAttribute(IntegerAttributeCallback callback) { + public void readAttachAttemptCountAttribute( + IntegerAttributeCallback callback + ) { readAttachAttemptCountAttribute(chipClusterPtr, callback); } - public void subscribeAttachAttemptCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartitionIdChangeCountAttribute(IntegerAttributeCallback callback) { + public void readPartitionIdChangeCountAttribute( + IntegerAttributeCallback callback + ) { readPartitionIdChangeCountAttribute(chipClusterPtr, callback); } - public void subscribePartitionIdChangeCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePartitionIdChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBetterPartitionAttachAttemptCountAttribute(IntegerAttributeCallback callback) { + public void readBetterPartitionAttachAttemptCountAttribute( + IntegerAttributeCallback callback + ) { readBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback); } - public void subscribeBetterPartitionAttachAttemptCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeBetterPartitionAttachAttemptCountAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readParentChangeCountAttribute(IntegerAttributeCallback callback) { + public void readParentChangeCountAttribute( + IntegerAttributeCallback callback + ) { readParentChangeCountAttribute(chipClusterPtr, callback); } - public void subscribeParentChangeCountAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeParentChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxTotalCountAttribute(LongAttributeCallback callback) { + public void readTxTotalCountAttribute( + LongAttributeCallback callback + ) { readTxTotalCountAttribute(chipClusterPtr, callback); } - public void subscribeTxTotalCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxUnicastCountAttribute(LongAttributeCallback callback) { + public void readTxUnicastCountAttribute( + LongAttributeCallback callback + ) { readTxUnicastCountAttribute(chipClusterPtr, callback); } - public void subscribeTxUnicastCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBroadcastCountAttribute(LongAttributeCallback callback) { + public void readTxBroadcastCountAttribute( + LongAttributeCallback callback + ) { readTxBroadcastCountAttribute(chipClusterPtr, callback); } - public void subscribeTxBroadcastCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxAckRequestedCountAttribute(LongAttributeCallback callback) { + public void readTxAckRequestedCountAttribute( + LongAttributeCallback callback + ) { readTxAckRequestedCountAttribute(chipClusterPtr, callback); } - public void subscribeTxAckRequestedCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxAckedCountAttribute(LongAttributeCallback callback) { + public void readTxAckedCountAttribute( + LongAttributeCallback callback + ) { readTxAckedCountAttribute(chipClusterPtr, callback); } - public void subscribeTxAckedCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxAckedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxNoAckRequestedCountAttribute(LongAttributeCallback callback) { + public void readTxNoAckRequestedCountAttribute( + LongAttributeCallback callback + ) { readTxNoAckRequestedCountAttribute(chipClusterPtr, callback); } - public void subscribeTxNoAckRequestedCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxNoAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDataCountAttribute(LongAttributeCallback callback) { + public void readTxDataCountAttribute( + LongAttributeCallback callback + ) { readTxDataCountAttribute(chipClusterPtr, callback); } - public void subscribeTxDataCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDataPollCountAttribute(LongAttributeCallback callback) { + public void readTxDataPollCountAttribute( + LongAttributeCallback callback + ) { readTxDataPollCountAttribute(chipClusterPtr, callback); } - public void subscribeTxDataPollCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBeaconCountAttribute(LongAttributeCallback callback) { + public void readTxBeaconCountAttribute( + LongAttributeCallback callback + ) { readTxBeaconCountAttribute(chipClusterPtr, callback); } - public void subscribeTxBeaconCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBeaconRequestCountAttribute(LongAttributeCallback callback) { + public void readTxBeaconRequestCountAttribute( + LongAttributeCallback callback + ) { readTxBeaconRequestCountAttribute(chipClusterPtr, callback); } - public void subscribeTxBeaconRequestCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxOtherCountAttribute(LongAttributeCallback callback) { + public void readTxOtherCountAttribute( + LongAttributeCallback callback + ) { readTxOtherCountAttribute(chipClusterPtr, callback); } - public void subscribeTxOtherCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxRetryCountAttribute(LongAttributeCallback callback) { + public void readTxRetryCountAttribute( + LongAttributeCallback callback + ) { readTxRetryCountAttribute(chipClusterPtr, callback); } - public void subscribeTxRetryCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxRetryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDirectMaxRetryExpiryCountAttribute(LongAttributeCallback callback) { + public void readTxDirectMaxRetryExpiryCountAttribute( + LongAttributeCallback callback + ) { readTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); } - public void subscribeTxDirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeTxDirectMaxRetryExpiryCountAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxIndirectMaxRetryExpiryCountAttribute(LongAttributeCallback callback) { + public void readTxIndirectMaxRetryExpiryCountAttribute( + LongAttributeCallback callback + ) { readTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); } - public void subscribeTxIndirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeTxIndirectMaxRetryExpiryCountAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrCcaCountAttribute(LongAttributeCallback callback) { + public void readTxErrCcaCountAttribute( + LongAttributeCallback callback + ) { readTxErrCcaCountAttribute(chipClusterPtr, callback); } - public void subscribeTxErrCcaCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxErrCcaCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrAbortCountAttribute(LongAttributeCallback callback) { + public void readTxErrAbortCountAttribute( + LongAttributeCallback callback + ) { readTxErrAbortCountAttribute(chipClusterPtr, callback); } - public void subscribeTxErrAbortCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxErrAbortCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrBusyChannelCountAttribute(LongAttributeCallback callback) { + public void readTxErrBusyChannelCountAttribute( + LongAttributeCallback callback + ) { readTxErrBusyChannelCountAttribute(chipClusterPtr, callback); } - public void subscribeTxErrBusyChannelCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTxErrBusyChannelCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxTotalCountAttribute(LongAttributeCallback callback) { + public void readRxTotalCountAttribute( + LongAttributeCallback callback + ) { readRxTotalCountAttribute(chipClusterPtr, callback); } - public void subscribeRxTotalCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxUnicastCountAttribute(LongAttributeCallback callback) { + public void readRxUnicastCountAttribute( + LongAttributeCallback callback + ) { readRxUnicastCountAttribute(chipClusterPtr, callback); } - public void subscribeRxUnicastCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBroadcastCountAttribute(LongAttributeCallback callback) { + public void readRxBroadcastCountAttribute( + LongAttributeCallback callback + ) { readRxBroadcastCountAttribute(chipClusterPtr, callback); } - public void subscribeRxBroadcastCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDataCountAttribute(LongAttributeCallback callback) { + public void readRxDataCountAttribute( + LongAttributeCallback callback + ) { readRxDataCountAttribute(chipClusterPtr, callback); } - public void subscribeRxDataCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDataPollCountAttribute(LongAttributeCallback callback) { + public void readRxDataPollCountAttribute( + LongAttributeCallback callback + ) { readRxDataPollCountAttribute(chipClusterPtr, callback); } - public void subscribeRxDataPollCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBeaconCountAttribute(LongAttributeCallback callback) { + public void readRxBeaconCountAttribute( + LongAttributeCallback callback + ) { readRxBeaconCountAttribute(chipClusterPtr, callback); } - public void subscribeRxBeaconCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBeaconRequestCountAttribute(LongAttributeCallback callback) { + public void readRxBeaconRequestCountAttribute( + LongAttributeCallback callback + ) { readRxBeaconRequestCountAttribute(chipClusterPtr, callback); } - public void subscribeRxBeaconRequestCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxOtherCountAttribute(LongAttributeCallback callback) { + public void readRxOtherCountAttribute( + LongAttributeCallback callback + ) { readRxOtherCountAttribute(chipClusterPtr, callback); } - public void subscribeRxOtherCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxAddressFilteredCountAttribute(LongAttributeCallback callback) { + public void readRxAddressFilteredCountAttribute( + LongAttributeCallback callback + ) { readRxAddressFilteredCountAttribute(chipClusterPtr, callback); } - public void subscribeRxAddressFilteredCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxAddressFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDestAddrFilteredCountAttribute(LongAttributeCallback callback) { + public void readRxDestAddrFilteredCountAttribute( + LongAttributeCallback callback + ) { readRxDestAddrFilteredCountAttribute(chipClusterPtr, callback); } - public void subscribeRxDestAddrFilteredCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxDestAddrFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDuplicatedCountAttribute(LongAttributeCallback callback) { + public void readRxDuplicatedCountAttribute( + LongAttributeCallback callback + ) { readRxDuplicatedCountAttribute(chipClusterPtr, callback); } - public void subscribeRxDuplicatedCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxDuplicatedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrNoFrameCountAttribute(LongAttributeCallback callback) { + public void readRxErrNoFrameCountAttribute( + LongAttributeCallback callback + ) { readRxErrNoFrameCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrNoFrameCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxErrNoFrameCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrUnknownNeighborCountAttribute(LongAttributeCallback callback) { + public void readRxErrUnknownNeighborCountAttribute( + LongAttributeCallback callback + ) { readRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrUnknownNeighborCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeRxErrUnknownNeighborCountAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrInvalidSrcAddrCountAttribute(LongAttributeCallback callback) { + public void readRxErrInvalidSrcAddrCountAttribute( + LongAttributeCallback callback + ) { readRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrInvalidSrcAddrCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { - subscribeRxErrInvalidSrcAddrCountAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrSecCountAttribute(LongAttributeCallback callback) { + public void readRxErrSecCountAttribute( + LongAttributeCallback callback + ) { readRxErrSecCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrSecCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxErrSecCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrFcsCountAttribute(LongAttributeCallback callback) { + public void readRxErrFcsCountAttribute( + LongAttributeCallback callback + ) { readRxErrFcsCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrFcsCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxErrFcsCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrOtherCountAttribute(LongAttributeCallback callback) { + public void readRxErrOtherCountAttribute( + LongAttributeCallback callback + ) { readRxErrOtherCountAttribute(chipClusterPtr, callback); } - public void subscribeRxErrOtherCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRxErrOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveTimestampAttribute(LongAttributeCallback callback) { + public void readActiveTimestampAttribute( + LongAttributeCallback callback + ) { readActiveTimestampAttribute(chipClusterPtr, callback); } - public void subscribeActiveTimestampAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActiveTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPendingTimestampAttribute(LongAttributeCallback callback) { + public void readPendingTimestampAttribute( + LongAttributeCallback callback + ) { readPendingTimestampAttribute(chipClusterPtr, callback); } - public void subscribePendingTimestampAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePendingTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDelayAttribute(LongAttributeCallback callback) { + public void readDelayAttribute( + LongAttributeCallback callback + ) { readDelayAttribute(chipClusterPtr, callback); } - public void subscribeDelayAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSecurityPolicyAttribute(SecurityPolicyAttributeCallback callback) { + public void readSecurityPolicyAttribute( + SecurityPolicyAttributeCallback callback + ) { readSecurityPolicyAttribute(chipClusterPtr, callback); } - public void subscribeSecurityPolicyAttribute( - SecurityPolicyAttributeCallback callback, int minInterval, int maxInterval) { - subscribeSecurityPolicyAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readChannelMaskAttribute(OctetStringAttributeCallback callback) { - readChannelMaskAttribute(chipClusterPtr, callback); - } - - public void subscribeChannelMaskAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { - subscribeChannelMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readOperationalDatasetComponentsAttribute( - OperationalDatasetComponentsAttributeCallback callback) { - readOperationalDatasetComponentsAttribute(chipClusterPtr, callback); - } - - public void subscribeOperationalDatasetComponentsAttribute( - OperationalDatasetComponentsAttributeCallback callback, int minInterval, int maxInterval) { - subscribeOperationalDatasetComponentsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); - } - - public void readActiveNetworkFaultsListAttribute( - ActiveNetworkFaultsListAttributeCallback callback) { - readActiveNetworkFaultsListAttribute(chipClusterPtr, callback); - } - - public void subscribeActiveNetworkFaultsListAttribute( - ActiveNetworkFaultsListAttributeCallback callback, int minInterval, int maxInterval) { - subscribeActiveNetworkFaultsListAttribute(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 readChannelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeChannelAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRoutingRoleAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRoutingRoleAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNetworkNameAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeNetworkNameAttribute( - long chipClusterPtr, - CharStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readPanIdAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePanIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readExtendedPanIdAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeExtendedPanIdAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readMeshLocalPrefixAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void subscribeMeshLocalPrefixAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readNeighborTableListAttribute( - long chipClusterPtr, NeighborTableListAttributeCallback callback); - - private native void subscribeNeighborTableListAttribute( - long chipClusterPtr, - NeighborTableListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readRouteTableListAttribute( - long chipClusterPtr, RouteTableListAttributeCallback callback); - - private native void subscribeRouteTableListAttribute( - long chipClusterPtr, - RouteTableListAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readPartitionIdAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePartitionIdAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readWeightingAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeWeightingAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDataVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeDataVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readStableDataVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeStableDataVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLeaderRouterIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLeaderRouterIdAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDetachedRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeDetachedRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readChildRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeChildRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRouterRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRouterRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readLeaderRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeLeaderRoleCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readAttachAttemptCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeAttachAttemptCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPartitionIdChangeCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribePartitionIdChangeCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBetterPartitionAttachAttemptCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeBetterPartitionAttachAttemptCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readParentChangeCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeParentChangeCountAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxTotalCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxTotalCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxUnicastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxUnicastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxBroadcastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxBroadcastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxAckRequestedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxAckRequestedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxAckedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxAckedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxNoAckRequestedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxNoAckRequestedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxDataCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxDataCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxDataPollCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxDataPollCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxBeaconCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxBeaconCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxBeaconRequestCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxBeaconRequestCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxRetryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxRetryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxDirectMaxRetryExpiryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxDirectMaxRetryExpiryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxIndirectMaxRetryExpiryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxIndirectMaxRetryExpiryCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxErrCcaCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxErrCcaCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxErrAbortCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxErrAbortCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTxErrBusyChannelCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeTxErrBusyChannelCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxTotalCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxTotalCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxUnicastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxUnicastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxBroadcastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxBroadcastCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxDataCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxDataCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxDataPollCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxDataPollCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxBeaconCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxBeaconCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxBeaconRequestCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxBeaconRequestCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxAddressFilteredCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxAddressFilteredCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxDestAddrFilteredCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxDestAddrFilteredCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxDuplicatedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxDuplicatedCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrNoFrameCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrNoFrameCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrUnknownNeighborCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrUnknownNeighborCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrInvalidSrcAddrCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrInvalidSrcAddrCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrSecCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrSecCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrFcsCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrFcsCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRxErrOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeRxErrOtherCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActiveTimestampAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeActiveTimestampAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPendingTimestampAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePendingTimestampAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readDelayAttribute(long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeDelayAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSecurityPolicyAttribute( - long chipClusterPtr, SecurityPolicyAttributeCallback callback); - - private native void subscribeSecurityPolicyAttribute( - long chipClusterPtr, - SecurityPolicyAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readChannelMaskAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void subscribeChannelMaskAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOperationalDatasetComponentsAttribute( - long chipClusterPtr, OperationalDatasetComponentsAttributeCallback callback); - - private native void subscribeOperationalDatasetComponentsAttribute( - long chipClusterPtr, - OperationalDatasetComponentsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readActiveNetworkFaultsListAttribute( - long chipClusterPtr, ActiveNetworkFaultsListAttributeCallback callback); + SecurityPolicyAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeSecurityPolicyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void subscribeActiveNetworkFaultsListAttribute( - long chipClusterPtr, - ActiveNetworkFaultsListAttributeCallback callback, - int minInterval, - int maxInterval); + public void readChannelMaskAttribute( + OctetStringAttributeCallback callback + ) { + readChannelMaskAttribute(chipClusterPtr, callback); + } + public void subscribeChannelMaskAttribute( + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeChannelMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readAttributeListAttribute( - long chipClusterPtr, AttributeListAttributeCallback callback); + public void readOperationalDatasetComponentsAttribute( + OperationalDatasetComponentsAttributeCallback callback + ) { + readOperationalDatasetComponentsAttribute(chipClusterPtr, callback); + } + public void subscribeOperationalDatasetComponentsAttribute( + OperationalDatasetComponentsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeOperationalDatasetComponentsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void subscribeAttributeListAttribute( - long chipClusterPtr, - AttributeListAttributeCallback callback, - int minInterval, - int maxInterval); + public void readActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback + ) { + readActiveNetworkFaultsListAttribute(chipClusterPtr, callback); + } + public void subscribeActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeActiveNetworkFaultsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readFeatureMapAttribute( - long chipClusterPtr, LongAttributeCallback callback); + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { + readAttributeListAttribute(chipClusterPtr, callback); + } + public void subscribeAttributeListAttribute( + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void subscribeFeatureMapAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { + readFeatureMapAttribute(chipClusterPtr, callback); + } + public void subscribeFeatureMapAttribute( + LongAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } - private native void readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + 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 subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readChannelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeChannelAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRoutingRoleAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRoutingRoleAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNetworkNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeNetworkNameAttribute(long chipClusterPtr, + CharStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPanIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePanIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readExtendedPanIdAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeExtendedPanIdAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readMeshLocalPrefixAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + private native void subscribeMeshLocalPrefixAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readNeighborTableListAttribute(long chipClusterPtr, + NeighborTableListAttributeCallback callback + ); + private native void subscribeNeighborTableListAttribute(long chipClusterPtr, + NeighborTableListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readRouteTableListAttribute(long chipClusterPtr, + RouteTableListAttributeCallback callback + ); + private native void subscribeRouteTableListAttribute(long chipClusterPtr, + RouteTableListAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readPartitionIdAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePartitionIdAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWeightingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeWeightingAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDataVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDataVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readStableDataVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeStableDataVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLeaderRouterIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLeaderRouterIdAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDetachedRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeDetachedRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readChildRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeChildRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRouterRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRouterRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readLeaderRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeLeaderRoleCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPartitionIdChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribePartitionIdChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readParentChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeParentChangeCountAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxAckedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxAckedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxNoAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxNoAckRequestedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxRetryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxRetryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrCcaCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrCcaCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrAbortCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrAbortCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTxErrBusyChannelCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeTxErrBusyChannelCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxTotalCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxUnicastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxBroadcastCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDataCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDataPollCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxBeaconCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxBeaconRequestCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxAddressFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxAddressFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDestAddrFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDestAddrFilteredCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxDuplicatedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxDuplicatedCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrNoFrameCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrNoFrameCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrUnknownNeighborCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrUnknownNeighborCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrSecCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrSecCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrFcsCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrFcsCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRxErrOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeRxErrOtherCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveTimestampAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeActiveTimestampAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPendingTimestampAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePendingTimestampAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readDelayAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeDelayAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSecurityPolicyAttribute(long chipClusterPtr, + SecurityPolicyAttributeCallback callback + ); + private native void subscribeSecurityPolicyAttribute(long chipClusterPtr, + SecurityPolicyAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readChannelMaskAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + private native void subscribeChannelMaskAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOperationalDatasetComponentsAttribute(long chipClusterPtr, + OperationalDatasetComponentsAttributeCallback callback + ); + private native void subscribeOperationalDatasetComponentsAttribute(long chipClusterPtr, + OperationalDatasetComponentsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readActiveNetworkFaultsListAttribute(long chipClusterPtr, + ActiveNetworkFaultsListAttributeCallback callback + ); + private native void subscribeActiveNetworkFaultsListAttribute(long chipClusterPtr, + ActiveNetworkFaultsListAttributeCallback 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 TimeFormatLocalizationCluster extends BaseChipCluster { @@ -17276,107 +16223,105 @@ public TimeFormatLocalizationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SupportedCalendarTypesAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface SupportedCalendarTypesAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readHourFormatAttribute(IntegerAttributeCallback callback) { + public void readHourFormatAttribute( + IntegerAttributeCallback callback + ) { readHourFormatAttribute(chipClusterPtr, callback); } - public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value) { writeHourFormatAttribute(chipClusterPtr, callback, value, null); } - public void writeHourFormatAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeHourFormatAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeHourFormatAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeHourFormatAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveCalendarTypeAttribute(IntegerAttributeCallback callback) { + public void readActiveCalendarTypeAttribute( + IntegerAttributeCallback callback + ) { readActiveCalendarTypeAttribute(chipClusterPtr, callback); } - public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value) { writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, null); } - public void writeActiveCalendarTypeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeActiveCalendarTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeActiveCalendarTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readSupportedCalendarTypesAttribute( - SupportedCalendarTypesAttributeCallback callback) { + SupportedCalendarTypesAttributeCallback callback + ) { readSupportedCalendarTypesAttribute(chipClusterPtr, callback); } - public void subscribeSupportedCalendarTypesAttribute( - SupportedCalendarTypesAttributeCallback callback, int minInterval, int maxInterval) { + SupportedCalendarTypesAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeSupportedCalendarTypesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readHourFormatAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeHourFormatAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeHourFormatAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readActiveCalendarTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeActiveCalendarTypeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeActiveCalendarTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSupportedCalendarTypesAttribute( - long chipClusterPtr, SupportedCalendarTypesAttributeCallback callback); - - private native void subscribeSupportedCalendarTypesAttribute( - long chipClusterPtr, - SupportedCalendarTypesAttributeCallback 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); + private native void readHourFormatAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeHourFormatAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeHourFormatAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readActiveCalendarTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeActiveCalendarTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeActiveCalendarTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSupportedCalendarTypesAttribute(long chipClusterPtr, + SupportedCalendarTypesAttributeCallback callback + ); + private native void subscribeSupportedCalendarTypesAttribute(long chipClusterPtr, + SupportedCalendarTypesAttributeCallback 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 UnitLocalizationCluster extends BaseChipCluster { @@ -17389,65 +16334,72 @@ public UnitLocalizationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void readTemperatureUnitAttribute(IntegerAttributeCallback callback) { + + public void readTemperatureUnitAttribute( + IntegerAttributeCallback callback + ) { readTemperatureUnitAttribute(chipClusterPtr, callback); } - public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value) { writeTemperatureUnitAttribute(chipClusterPtr, callback, value, null); } - public void writeTemperatureUnitAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeTemperatureUnitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeTemperatureUnitAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTemperatureUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTemperatureUnitAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeTemperatureUnitAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeTemperatureUnitAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readTemperatureUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeTemperatureUnitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeTemperatureUnitAttribute(long chipClusterPtr, + IntegerAttributeCallback 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 UserLabelCluster extends BaseChipCluster { @@ -17460,61 +16412,58 @@ public UserLabelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LabelListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface LabelListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readLabelListAttribute(LabelListAttributeCallback callback) { + public void readLabelListAttribute( + LabelListAttributeCallback callback + ) { readLabelListAttribute(chipClusterPtr, callback); } - - public void writeLabelListAttribute( - DefaultClusterCallback callback, ArrayList value) { + public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value) { writeLabelListAttribute(chipClusterPtr, callback, value, null); } - public void writeLabelListAttribute( - DefaultClusterCallback callback, - ArrayList value, - int timedWriteTimeoutMs) { + public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeLabelListAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeLabelListAttribute( - LabelListAttributeCallback callback, int minInterval, int maxInterval) { + LabelListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLabelListAttribute( - long chipClusterPtr, LabelListAttributeCallback callback); - - private native void writeLabelListAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - ArrayList value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeLabelListAttribute( - long chipClusterPtr, LabelListAttributeCallback callback, int minInterval, int maxInterval); + private native void readLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback callback + ); - private native void readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); + private native void writeLabelListAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeLabelListAttribute(long chipClusterPtr, + LabelListAttributeCallback callback + , int minInterval, int maxInterval); - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback 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 WakeOnLanCluster extends BaseChipCluster { @@ -17527,64 +16476,68 @@ public WakeOnLanCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readWakeOnLanMacAddressAttribute(CharStringAttributeCallback callback) { + public void readWakeOnLanMacAddressAttribute( + CharStringAttributeCallback callback + ) { readWakeOnLanMacAddressAttribute(chipClusterPtr, callback); } - public void subscribeWakeOnLanMacAddressAttribute( - CharStringAttributeCallback callback, int minInterval, int maxInterval) { + CharStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWakeOnLanMacAddressAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readWakeOnLanMacAddressAttribute( - long chipClusterPtr, CharStringAttributeCallback callback); - - private native void subscribeWakeOnLanMacAddressAttribute( - long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeClusterRevisionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + private native void readWakeOnLanMacAddressAttribute(long chipClusterPtr, + CharStringAttributeCallback callback + ); + private native void subscribeWakeOnLanMacAddressAttribute(long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeClusterRevisionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); } public static class WiFiNetworkDiagnosticsCluster extends BaseChipCluster { @@ -17597,272 +16550,329 @@ public WiFiNetworkDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetCounts(DefaultClusterCallback callback) { + public void resetCounts(DefaultClusterCallback callback + ) { resetCounts(chipClusterPtr, callback, null); } - public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void resetCounts(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); - private native void resetCounts( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - public void readBssidAttribute(OctetStringAttributeCallback callback) { + public void readBssidAttribute( + OctetStringAttributeCallback callback + ) { readBssidAttribute(chipClusterPtr, callback); } - public void subscribeBssidAttribute( - OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + OctetStringAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBssidAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSecurityTypeAttribute(IntegerAttributeCallback callback) { + public void readSecurityTypeAttribute( + IntegerAttributeCallback callback + ) { readSecurityTypeAttribute(chipClusterPtr, callback); } - public void subscribeSecurityTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSecurityTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWiFiVersionAttribute(IntegerAttributeCallback callback) { + public void readWiFiVersionAttribute( + IntegerAttributeCallback callback + ) { readWiFiVersionAttribute(chipClusterPtr, callback); } - public void subscribeWiFiVersionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeWiFiVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readChannelNumberAttribute(IntegerAttributeCallback callback) { + public void readChannelNumberAttribute( + IntegerAttributeCallback callback + ) { readChannelNumberAttribute(chipClusterPtr, callback); } - public void subscribeChannelNumberAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeChannelNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRssiAttribute(IntegerAttributeCallback callback) { + public void readRssiAttribute( + IntegerAttributeCallback callback + ) { readRssiAttribute(chipClusterPtr, callback); } - public void subscribeRssiAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeRssiAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBeaconLostCountAttribute(LongAttributeCallback callback) { + public void readBeaconLostCountAttribute( + LongAttributeCallback callback + ) { readBeaconLostCountAttribute(chipClusterPtr, callback); } - public void subscribeBeaconLostCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBeaconLostCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBeaconRxCountAttribute(LongAttributeCallback callback) { + public void readBeaconRxCountAttribute( + LongAttributeCallback callback + ) { readBeaconRxCountAttribute(chipClusterPtr, callback); } - public void subscribeBeaconRxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeBeaconRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketMulticastRxCountAttribute(LongAttributeCallback callback) { + public void readPacketMulticastRxCountAttribute( + LongAttributeCallback callback + ) { readPacketMulticastRxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketMulticastRxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketMulticastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketMulticastTxCountAttribute(LongAttributeCallback callback) { + public void readPacketMulticastTxCountAttribute( + LongAttributeCallback callback + ) { readPacketMulticastTxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketMulticastTxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketMulticastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketUnicastRxCountAttribute(LongAttributeCallback callback) { + public void readPacketUnicastRxCountAttribute( + LongAttributeCallback callback + ) { readPacketUnicastRxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketUnicastRxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketUnicastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketUnicastTxCountAttribute(LongAttributeCallback callback) { + public void readPacketUnicastTxCountAttribute( + LongAttributeCallback callback + ) { readPacketUnicastTxCountAttribute(chipClusterPtr, callback); } - public void subscribePacketUnicastTxCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribePacketUnicastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentMaxRateAttribute(LongAttributeCallback callback) { + public void readCurrentMaxRateAttribute( + LongAttributeCallback callback + ) { readCurrentMaxRateAttribute(chipClusterPtr, callback); } - public void subscribeCurrentMaxRateAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeCurrentMaxRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute(LongAttributeCallback callback) { + public void readOverrunCountAttribute( + LongAttributeCallback callback + ) { readOverrunCountAttribute(chipClusterPtr, callback); } - public void subscribeOverrunCountAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBssidAttribute( - long chipClusterPtr, OctetStringAttributeCallback callback); - - private native void subscribeBssidAttribute( - long chipClusterPtr, - OctetStringAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readSecurityTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSecurityTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readWiFiVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeWiFiVersionAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readChannelNumberAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeChannelNumberAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readRssiAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeRssiAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBeaconLostCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeBeaconLostCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readBeaconRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeBeaconRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketMulticastRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketMulticastRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketMulticastTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketMulticastTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketUnicastRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketUnicastRxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readPacketUnicastTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribePacketUnicastTxCountAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentMaxRateAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeCurrentMaxRateAttribute( - long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback callback); - - private native void subscribeOverrunCountAttribute( - long chipClusterPtr, LongAttributeCallback 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); + private native void readBssidAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback + ); + private native void subscribeBssidAttribute(long chipClusterPtr, + OctetStringAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSecurityTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSecurityTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readWiFiVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeWiFiVersionAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readChannelNumberAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeChannelNumberAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readRssiAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeRssiAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBeaconLostCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeBeaconLostCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readBeaconRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeBeaconRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketMulticastRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketMulticastRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketMulticastTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketMulticastTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketUnicastRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketUnicastRxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readPacketUnicastTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribePacketUnicastTxCountAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentMaxRateAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeCurrentMaxRateAttribute(long chipClusterPtr, + LongAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback callback + ); + private native void subscribeOverrunCountAttribute(long chipClusterPtr, + LongAttributeCallback 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 WindowCoveringCluster extends BaseChipCluster { @@ -17875,581 +16885,556 @@ public WindowCoveringCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void downOrClose(DefaultClusterCallback callback) { + public void downOrClose(DefaultClusterCallback callback + ) { downOrClose(chipClusterPtr, callback, null); } - public void downOrClose(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void downOrClose(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { downOrClose(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void goToLiftPercentage( - DefaultClusterCallback callback, - Integer liftPercentageValue, - Integer liftPercent100thsValue) { - goToLiftPercentage( - chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, null); + public void goToLiftPercentage(DefaultClusterCallback callback + , Integer liftPercentageValue, Integer liftPercent100thsValue) { + goToLiftPercentage(chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, null); } - public void goToLiftPercentage( - DefaultClusterCallback callback, - Integer liftPercentageValue, - Integer liftPercent100thsValue, - int timedInvokeTimeoutMs) { - goToLiftPercentage( - chipClusterPtr, - callback, - liftPercentageValue, - liftPercent100thsValue, - timedInvokeTimeoutMs); + public void goToLiftPercentage(DefaultClusterCallback callback + , Integer liftPercentageValue, Integer liftPercent100thsValue + , int timedInvokeTimeoutMs) { + goToLiftPercentage(chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, timedInvokeTimeoutMs); } - public void goToLiftValue(DefaultClusterCallback callback, Integer liftValue) { + public void goToLiftValue(DefaultClusterCallback callback + , Integer liftValue) { goToLiftValue(chipClusterPtr, callback, liftValue, null); } - public void goToLiftValue( - DefaultClusterCallback callback, Integer liftValue, int timedInvokeTimeoutMs) { + public void goToLiftValue(DefaultClusterCallback callback + , Integer liftValue + , int timedInvokeTimeoutMs) { goToLiftValue(chipClusterPtr, callback, liftValue, timedInvokeTimeoutMs); } - public void goToTiltPercentage( - DefaultClusterCallback callback, - Integer tiltPercentageValue, - Integer tiltPercent100thsValue) { - goToTiltPercentage( - chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, null); + public void goToTiltPercentage(DefaultClusterCallback callback + , Integer tiltPercentageValue, Integer tiltPercent100thsValue) { + goToTiltPercentage(chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, null); } - public void goToTiltPercentage( - DefaultClusterCallback callback, - Integer tiltPercentageValue, - Integer tiltPercent100thsValue, - int timedInvokeTimeoutMs) { - goToTiltPercentage( - chipClusterPtr, - callback, - tiltPercentageValue, - tiltPercent100thsValue, - timedInvokeTimeoutMs); + public void goToTiltPercentage(DefaultClusterCallback callback + , Integer tiltPercentageValue, Integer tiltPercent100thsValue + , int timedInvokeTimeoutMs) { + goToTiltPercentage(chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, timedInvokeTimeoutMs); } - public void goToTiltValue(DefaultClusterCallback callback, Integer tiltValue) { + public void goToTiltValue(DefaultClusterCallback callback + , Integer tiltValue) { goToTiltValue(chipClusterPtr, callback, tiltValue, null); } - public void goToTiltValue( - DefaultClusterCallback callback, Integer tiltValue, int timedInvokeTimeoutMs) { + public void goToTiltValue(DefaultClusterCallback callback + , Integer tiltValue + , int timedInvokeTimeoutMs) { goToTiltValue(chipClusterPtr, callback, tiltValue, timedInvokeTimeoutMs); } - public void stopMotion(DefaultClusterCallback callback) { + public void stopMotion(DefaultClusterCallback callback + ) { stopMotion(chipClusterPtr, callback, null); } - public void stopMotion(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void stopMotion(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { stopMotion(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void upOrOpen(DefaultClusterCallback callback) { + public void upOrOpen(DefaultClusterCallback callback + ) { upOrOpen(chipClusterPtr, callback, null); } - public void upOrOpen(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - + public void upOrOpen(DefaultClusterCallback callback + + , int timedInvokeTimeoutMs) { upOrOpen(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void downOrClose(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToLiftPercentage(long chipClusterPtr, DefaultClusterCallback Callback + , Integer liftPercentageValue, Integer liftPercent100thsValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToLiftValue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer liftValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToTiltPercentage(long chipClusterPtr, DefaultClusterCallback Callback + , Integer tiltPercentageValue, Integer tiltPercent100thsValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void goToTiltValue(long chipClusterPtr, DefaultClusterCallback Callback + , Integer tiltValue + , @Nullable Integer timedInvokeTimeoutMs); + private native void stopMotion(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + private native void upOrOpen(long chipClusterPtr, DefaultClusterCallback Callback + + , @Nullable Integer timedInvokeTimeoutMs); + + public interface CurrentPositionLiftAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentPositionTiltAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentPositionLiftPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentPositionTiltPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface TargetPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface TargetPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface CurrentPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } + public interface AttributeListAttributeCallback { + void onSuccess( List valueList); + void onError(Exception ex); + default void onSubscriptionEstablished() {} + } - private native void downOrClose( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void goToLiftPercentage( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer liftPercentageValue, - Integer liftPercent100thsValue, - @Nullable Integer timedInvokeTimeoutMs); - - private native void goToLiftValue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer liftValue, - @Nullable Integer timedInvokeTimeoutMs); - - private native void goToTiltPercentage( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer tiltPercentageValue, - Integer tiltPercent100thsValue, - @Nullable Integer timedInvokeTimeoutMs); - - private native void goToTiltValue( - long chipClusterPtr, - DefaultClusterCallback Callback, - Integer tiltValue, - @Nullable Integer timedInvokeTimeoutMs); - - private native void stopMotion( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - private native void upOrOpen( - long chipClusterPtr, - DefaultClusterCallback Callback, - @Nullable Integer timedInvokeTimeoutMs); - - public interface CurrentPositionLiftAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentPositionTiltAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentPositionLiftPercentageAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentPositionTiltPercentageAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface TargetPositionLiftPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface TargetPositionTiltPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentPositionLiftPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface CurrentPositionTiltPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public interface AttributeListAttributeCallback { - void onSuccess(List valueList); - - void onError(Exception ex); - - default void onSubscriptionEstablished() {} - } - - public void readTypeAttribute(IntegerAttributeCallback callback) { + public void readTypeAttribute( + IntegerAttributeCallback callback + ) { readTypeAttribute(chipClusterPtr, callback); } - public void subscribeTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionLiftAttribute(CurrentPositionLiftAttributeCallback callback) { + public void readCurrentPositionLiftAttribute( + CurrentPositionLiftAttributeCallback callback + ) { readCurrentPositionLiftAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionLiftAttribute( - CurrentPositionLiftAttributeCallback callback, int minInterval, int maxInterval) { + CurrentPositionLiftAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeCurrentPositionLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionTiltAttribute(CurrentPositionTiltAttributeCallback callback) { + public void readCurrentPositionTiltAttribute( + CurrentPositionTiltAttributeCallback callback + ) { readCurrentPositionTiltAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionTiltAttribute( - CurrentPositionTiltAttributeCallback callback, int minInterval, int maxInterval) { + CurrentPositionTiltAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeCurrentPositionTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readConfigStatusAttribute(IntegerAttributeCallback callback) { + public void readConfigStatusAttribute( + IntegerAttributeCallback callback + ) { readConfigStatusAttribute(chipClusterPtr, callback); } - public void subscribeConfigStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeConfigStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionLiftPercentageAttribute( - CurrentPositionLiftPercentageAttributeCallback callback) { + CurrentPositionLiftPercentageAttributeCallback callback + ) { readCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionLiftPercentageAttribute( - CurrentPositionLiftPercentageAttributeCallback callback, int minInterval, int maxInterval) { - subscribeCurrentPositionLiftPercentageAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionLiftPercentageAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionTiltPercentageAttribute( - CurrentPositionTiltPercentageAttributeCallback callback) { + CurrentPositionTiltPercentageAttributeCallback callback + ) { readCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionTiltPercentageAttribute( - CurrentPositionTiltPercentageAttributeCallback callback, int minInterval, int maxInterval) { - subscribeCurrentPositionTiltPercentageAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionTiltPercentageAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperationalStatusAttribute(IntegerAttributeCallback callback) { + public void readOperationalStatusAttribute( + IntegerAttributeCallback callback + ) { readOperationalStatusAttribute(chipClusterPtr, callback); } - public void subscribeOperationalStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeOperationalStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTargetPositionLiftPercent100thsAttribute( - TargetPositionLiftPercent100thsAttributeCallback callback) { + TargetPositionLiftPercent100thsAttributeCallback callback + ) { readTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback); } - public void subscribeTargetPositionLiftPercent100thsAttribute( - TargetPositionLiftPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval) { - subscribeTargetPositionLiftPercent100thsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + TargetPositionLiftPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTargetPositionTiltPercent100thsAttribute( - TargetPositionTiltPercent100thsAttributeCallback callback) { + TargetPositionTiltPercent100thsAttributeCallback callback + ) { readTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback); } - public void subscribeTargetPositionTiltPercent100thsAttribute( - TargetPositionTiltPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval) { - subscribeTargetPositionTiltPercent100thsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + TargetPositionTiltPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEndProductTypeAttribute(IntegerAttributeCallback callback) { + public void readEndProductTypeAttribute( + IntegerAttributeCallback callback + ) { readEndProductTypeAttribute(chipClusterPtr, callback); } - public void subscribeEndProductTypeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeEndProductTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionLiftPercent100thsAttribute( - CurrentPositionLiftPercent100thsAttributeCallback callback) { + CurrentPositionLiftPercent100thsAttributeCallback callback + ) { readCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionLiftPercent100thsAttribute( - CurrentPositionLiftPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval) { - subscribeCurrentPositionLiftPercent100thsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionLiftPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionTiltPercent100thsAttribute( - CurrentPositionTiltPercent100thsAttributeCallback callback) { + CurrentPositionTiltPercent100thsAttributeCallback callback + ) { readCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback); } - public void subscribeCurrentPositionTiltPercent100thsAttribute( - CurrentPositionTiltPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval) { - subscribeCurrentPositionTiltPercent100thsAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionTiltPercent100thsAttributeCallback callback + , + int minInterval, int maxInterval) { + subscribeCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledOpenLimitLiftAttribute(IntegerAttributeCallback callback) { + public void readInstalledOpenLimitLiftAttribute( + IntegerAttributeCallback callback + ) { readInstalledOpenLimitLiftAttribute(chipClusterPtr, callback); } - public void subscribeInstalledOpenLimitLiftAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInstalledOpenLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledClosedLimitLiftAttribute(IntegerAttributeCallback callback) { + public void readInstalledClosedLimitLiftAttribute( + IntegerAttributeCallback callback + ) { readInstalledClosedLimitLiftAttribute(chipClusterPtr, callback); } - public void subscribeInstalledClosedLimitLiftAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeInstalledClosedLimitLiftAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstalledClosedLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledOpenLimitTiltAttribute(IntegerAttributeCallback callback) { + public void readInstalledOpenLimitTiltAttribute( + IntegerAttributeCallback callback + ) { readInstalledOpenLimitTiltAttribute(chipClusterPtr, callback); } - public void subscribeInstalledOpenLimitTiltAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeInstalledOpenLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledClosedLimitTiltAttribute(IntegerAttributeCallback callback) { + public void readInstalledClosedLimitTiltAttribute( + IntegerAttributeCallback callback + ) { readInstalledClosedLimitTiltAttribute(chipClusterPtr, callback); } - public void subscribeInstalledClosedLimitTiltAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { - subscribeInstalledClosedLimitTiltAttribute( - chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { + subscribeInstalledClosedLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readModeAttribute(IntegerAttributeCallback callback) { + public void readModeAttribute( + IntegerAttributeCallback callback + ) { readModeAttribute(chipClusterPtr, callback); } - public void writeModeAttribute(DefaultClusterCallback callback, Integer value) { writeModeAttribute(chipClusterPtr, callback, value, null); } - public void writeModeAttribute( - DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } - public void subscribeModeAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSafetyStatusAttribute(IntegerAttributeCallback callback) { + public void readSafetyStatusAttribute( + IntegerAttributeCallback callback + ) { readSafetyStatusAttribute(chipClusterPtr, callback); } - public void subscribeSafetyStatusAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute(AttributeListAttributeCallback callback) { + public void readAttributeListAttribute( + AttributeListAttributeCallback callback + ) { readAttributeListAttribute(chipClusterPtr, callback); } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback, int minInterval, int maxInterval) { + AttributeListAttributeCallback callback + , + int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute(LongAttributeCallback callback) { + public void readFeatureMapAttribute( + LongAttributeCallback callback + ) { readFeatureMapAttribute(chipClusterPtr, callback); } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback, int minInterval, int maxInterval) { + LongAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { + public void readClusterRevisionAttribute( + IntegerAttributeCallback callback + ) { readClusterRevisionAttribute(chipClusterPtr, callback); } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback, int minInterval, int maxInterval) { + IntegerAttributeCallback callback +, + int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftAttribute( - long chipClusterPtr, CurrentPositionLiftAttributeCallback callback); - - private native void subscribeCurrentPositionLiftAttribute( - long chipClusterPtr, - CurrentPositionLiftAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentPositionTiltAttribute( - long chipClusterPtr, CurrentPositionTiltAttributeCallback callback); - - private native void subscribeCurrentPositionTiltAttribute( - long chipClusterPtr, - CurrentPositionTiltAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readConfigStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeConfigStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftPercentageAttribute( - long chipClusterPtr, CurrentPositionLiftPercentageAttributeCallback callback); - - private native void subscribeCurrentPositionLiftPercentageAttribute( - long chipClusterPtr, - CurrentPositionLiftPercentageAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentPositionTiltPercentageAttribute( - long chipClusterPtr, CurrentPositionTiltPercentageAttributeCallback callback); - - private native void subscribeCurrentPositionTiltPercentageAttribute( - long chipClusterPtr, - CurrentPositionTiltPercentageAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readOperationalStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeOperationalStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readTargetPositionLiftPercent100thsAttribute( - long chipClusterPtr, TargetPositionLiftPercent100thsAttributeCallback callback); - - private native void subscribeTargetPositionLiftPercent100thsAttribute( - long chipClusterPtr, - TargetPositionLiftPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readTargetPositionTiltPercent100thsAttribute( - long chipClusterPtr, TargetPositionTiltPercent100thsAttributeCallback callback); - - private native void subscribeTargetPositionTiltPercent100thsAttribute( - long chipClusterPtr, - TargetPositionTiltPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readEndProductTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeEndProductTypeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftPercent100thsAttribute( - long chipClusterPtr, CurrentPositionLiftPercent100thsAttributeCallback callback); - - private native void subscribeCurrentPositionLiftPercent100thsAttribute( - long chipClusterPtr, - CurrentPositionLiftPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readCurrentPositionTiltPercent100thsAttribute( - long chipClusterPtr, CurrentPositionTiltPercent100thsAttributeCallback callback); - - private native void subscribeCurrentPositionTiltPercent100thsAttribute( - long chipClusterPtr, - CurrentPositionTiltPercent100thsAttributeCallback callback, - int minInterval, - int maxInterval); - - private native void readInstalledOpenLimitLiftAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeInstalledOpenLimitLiftAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInstalledClosedLimitLiftAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeInstalledClosedLimitLiftAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInstalledOpenLimitTiltAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeInstalledOpenLimitTiltAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readInstalledClosedLimitTiltAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeInstalledClosedLimitTiltAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); - - private native void writeModeAttribute( - long chipClusterPtr, - DefaultClusterCallback callback, - Integer value, - @Nullable Integer timedWriteTimeoutMs); - - private native void subscribeModeAttribute( - long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - - private native void readSafetyStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback callback); - - private native void subscribeSafetyStatusAttribute( - long chipClusterPtr, IntegerAttributeCallback 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); + private native void readTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftAttribute(long chipClusterPtr, + CurrentPositionLiftAttributeCallback callback + ); + private native void subscribeCurrentPositionLiftAttribute(long chipClusterPtr, + CurrentPositionLiftAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentPositionTiltAttribute(long chipClusterPtr, + CurrentPositionTiltAttributeCallback callback + ); + private native void subscribeCurrentPositionTiltAttribute(long chipClusterPtr, + CurrentPositionTiltAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readConfigStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeConfigStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercentageAttribute(long chipClusterPtr, + CurrentPositionLiftPercentageAttributeCallback callback + ); + private native void subscribeCurrentPositionLiftPercentageAttribute(long chipClusterPtr, + CurrentPositionLiftPercentageAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentPositionTiltPercentageAttribute(long chipClusterPtr, + CurrentPositionTiltPercentageAttributeCallback callback + ); + private native void subscribeCurrentPositionTiltPercentageAttribute(long chipClusterPtr, + CurrentPositionTiltPercentageAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readOperationalStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeOperationalStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, + TargetPositionLiftPercent100thsAttributeCallback callback + ); + private native void subscribeTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, + TargetPositionLiftPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, + TargetPositionTiltPercent100thsAttributeCallback callback + ); + private native void subscribeTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, + TargetPositionTiltPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readEndProductTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeEndProductTypeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, + CurrentPositionLiftPercent100thsAttributeCallback callback + ); + private native void subscribeCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, + CurrentPositionLiftPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, + CurrentPositionTiltPercent100thsAttributeCallback callback + ); + private native void subscribeCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, + CurrentPositionTiltPercent100thsAttributeCallback callback + , int minInterval, int maxInterval); + + private native void readInstalledOpenLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledOpenLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledClosedLimitLiftAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstalledOpenLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledOpenLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeInstalledClosedLimitTiltAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + + private native void writeModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); + private native void subscribeModeAttribute(long chipClusterPtr, + IntegerAttributeCallback callback +, int minInterval, int maxInterval); + + private native void readSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback callback + ); + private native void subscribeSafetyStatusAttribute(long chipClusterPtr, + IntegerAttributeCallback 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); } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java index bbbf6488468e15..23446754ab399f 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java @@ -24,1975 +24,2110 @@ import java.util.Optional; public class ChipStructs { - public static class AccessControlClusterTarget { - public @Nullable Long cluster; - public @Nullable Integer endpoint; - public @Nullable Long deviceType; - - public AccessControlClusterTarget( - @Nullable Long cluster, @Nullable Integer endpoint, @Nullable Long deviceType) { - this.cluster = cluster; - this.endpoint = endpoint; - this.deviceType = deviceType; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterTarget {\n"); - output.append("\tcluster: "); - output.append(cluster); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("\tdeviceType: "); - output.append(deviceType); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class AccessControlClusterAccessControlEntry { - public Integer fabricIndex; - public Integer privilege; - public Integer authMode; - public @Nullable ArrayList subjects; - public @Nullable ArrayList targets; - - public AccessControlClusterAccessControlEntry( - Integer fabricIndex, - Integer privilege, - Integer authMode, - @Nullable ArrayList subjects, - @Nullable ArrayList targets) { - this.fabricIndex = fabricIndex; - this.privilege = privilege; - this.authMode = authMode; - this.subjects = subjects; - this.targets = targets; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterAccessControlEntry {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tprivilege: "); - output.append(privilege); - output.append("\n"); - output.append("\tauthMode: "); - output.append(authMode); - output.append("\n"); - output.append("\tsubjects: "); - output.append(subjects); - output.append("\n"); - output.append("\ttargets: "); - output.append(targets); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class AccessControlClusterExtensionEntry { - public Integer fabricIndex; - public byte[] data; - - public AccessControlClusterExtensionEntry(Integer fabricIndex, byte[] data) { - this.fabricIndex = fabricIndex; - this.data = data; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterExtensionEntry {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tdata: "); - output.append(Arrays.toString(data)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ApplicationBasicClusterApplicationBasicApplication { - public Integer catalogVendorId; - public String applicationId; - - public ApplicationBasicClusterApplicationBasicApplication( - Integer catalogVendorId, String applicationId) { - this.catalogVendorId = catalogVendorId; - this.applicationId = applicationId; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationBasicClusterApplicationBasicApplication {\n"); - output.append("\tcatalogVendorId: "); - output.append(catalogVendorId); - output.append("\n"); - output.append("\tapplicationId: "); - output.append(applicationId); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ApplicationLauncherClusterApplicationLauncherApplication { - public Integer catalogVendorId; - public String applicationId; - - public ApplicationLauncherClusterApplicationLauncherApplication( - Integer catalogVendorId, String applicationId) { - this.catalogVendorId = catalogVendorId; - this.applicationId = applicationId; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationLauncherClusterApplicationLauncherApplication {\n"); - output.append("\tcatalogVendorId: "); - output.append(catalogVendorId); - output.append("\n"); - output.append("\tapplicationId: "); - output.append(applicationId); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ApplicationLauncherClusterApplicationEP { - public ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application; - public String endpoint; - - public ApplicationLauncherClusterApplicationEP( - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, - String endpoint) { - this.application = application; - this.endpoint = endpoint; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationLauncherClusterApplicationEP {\n"); - output.append("\tapplication: "); - output.append(application); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class AudioOutputClusterOutputInfo { - public Integer index; - public Integer outputType; - public String name; - - public AudioOutputClusterOutputInfo(Integer index, Integer outputType, String name) { - this.index = index; - this.outputType = outputType; - this.name = name; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AudioOutputClusterOutputInfo {\n"); - output.append("\tindex: "); - output.append(index); - output.append("\n"); - output.append("\toutputType: "); - output.append(outputType); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class BridgedActionsClusterActionStruct { - public Integer actionID; - public String name; - public Integer type; - public Integer endpointListID; - public Integer supportedCommands; - public Integer status; - - public BridgedActionsClusterActionStruct( - Integer actionID, - String name, - Integer type, - Integer endpointListID, - Integer supportedCommands, - Integer status) { - this.actionID = actionID; - this.name = name; - this.type = type; - this.endpointListID = endpointListID; - this.supportedCommands = supportedCommands; - this.status = status; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedActionsClusterActionStruct {\n"); - output.append("\tactionID: "); - output.append(actionID); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tendpointListID: "); - output.append(endpointListID); - output.append("\n"); - output.append("\tsupportedCommands: "); - output.append(supportedCommands); - output.append("\n"); - output.append("\tstatus: "); - output.append(status); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class BridgedActionsClusterEndpointListStruct { - public Integer endpointListID; - public String name; - public Integer type; - public ArrayList endpoints; - - public BridgedActionsClusterEndpointListStruct( - Integer endpointListID, String name, Integer type, ArrayList endpoints) { - this.endpointListID = endpointListID; - this.name = name; - this.type = type; - this.endpoints = endpoints; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedActionsClusterEndpointListStruct {\n"); - output.append("\tendpointListID: "); - output.append(endpointListID); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tendpoints: "); - output.append(endpoints); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ChannelClusterChannelInfo { - public Integer majorNumber; - public Integer minorNumber; - public String name; - public String callSign; - public String affiliateCallSign; - - public ChannelClusterChannelInfo( - Integer majorNumber, - Integer minorNumber, - String name, - String callSign, - String affiliateCallSign) { - this.majorNumber = majorNumber; - this.minorNumber = minorNumber; - this.name = name; - this.callSign = callSign; - this.affiliateCallSign = affiliateCallSign; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ChannelClusterChannelInfo {\n"); - output.append("\tmajorNumber: "); - output.append(majorNumber); - output.append("\n"); - output.append("\tminorNumber: "); - output.append(minorNumber); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tcallSign: "); - output.append(callSign); - output.append("\n"); - output.append("\taffiliateCallSign: "); - output.append(affiliateCallSign); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ChannelClusterLineupInfo { - public String operatorName; - public String lineupName; - public String postalCode; - public Integer lineupInfoType; - - public ChannelClusterLineupInfo( - String operatorName, String lineupName, String postalCode, Integer lineupInfoType) { - this.operatorName = operatorName; - this.lineupName = lineupName; - this.postalCode = postalCode; - this.lineupInfoType = lineupInfoType; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ChannelClusterLineupInfo {\n"); - output.append("\toperatorName: "); - output.append(operatorName); - output.append("\n"); - output.append("\tlineupName: "); - output.append(lineupName); - output.append("\n"); - output.append("\tpostalCode: "); - output.append(postalCode); - output.append("\n"); - output.append("\tlineupInfoType: "); - output.append(lineupInfoType); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterDimension { - public Double width; - public Double height; - public Integer metric; - - public ContentLauncherClusterDimension(Double width, Double height, Integer metric) { - this.width = width; - this.height = height; - this.metric = metric; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterDimension {\n"); - output.append("\twidth: "); - output.append(width); - output.append("\n"); - output.append("\theight: "); - output.append(height); - output.append("\n"); - output.append("\tmetric: "); - output.append(metric); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterAdditionalInfo { - public String name; - public String value; - - public ContentLauncherClusterAdditionalInfo(String name, String value) { - this.name = name; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterAdditionalInfo {\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterParameter { - public Integer type; - public String value; - public ArrayList externalIDList; - - public ContentLauncherClusterParameter( - Integer type, - String value, - ArrayList externalIDList) { - this.type = type; - this.value = value; - this.externalIDList = externalIDList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterParameter {\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("\texternalIDList: "); - output.append(externalIDList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterContentSearch { - public ArrayList parameterList; - - public ContentLauncherClusterContentSearch( - ArrayList parameterList) { - this.parameterList = parameterList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterContentSearch {\n"); - output.append("\tparameterList: "); - output.append(parameterList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterStyleInformation { - public String imageUrl; - public String color; - public ChipStructs.ContentLauncherClusterDimension size; - - public ContentLauncherClusterStyleInformation( - String imageUrl, String color, ChipStructs.ContentLauncherClusterDimension size) { - this.imageUrl = imageUrl; - this.color = color; - this.size = size; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterStyleInformation {\n"); - output.append("\timageUrl: "); - output.append(imageUrl); - output.append("\n"); - output.append("\tcolor: "); - output.append(color); - output.append("\n"); - output.append("\tsize: "); - output.append(size); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ContentLauncherClusterBrandingInformation { - public String providerName; - public ChipStructs.ContentLauncherClusterStyleInformation background; - public ChipStructs.ContentLauncherClusterStyleInformation logo; - public ChipStructs.ContentLauncherClusterStyleInformation progressBar; - public ChipStructs.ContentLauncherClusterStyleInformation splash; - public ChipStructs.ContentLauncherClusterStyleInformation waterMark; - - public ContentLauncherClusterBrandingInformation( - String providerName, - ChipStructs.ContentLauncherClusterStyleInformation background, - ChipStructs.ContentLauncherClusterStyleInformation logo, - ChipStructs.ContentLauncherClusterStyleInformation progressBar, - ChipStructs.ContentLauncherClusterStyleInformation splash, - ChipStructs.ContentLauncherClusterStyleInformation waterMark) { - this.providerName = providerName; - this.background = background; - this.logo = logo; - this.progressBar = progressBar; - this.splash = splash; - this.waterMark = waterMark; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterBrandingInformation {\n"); - output.append("\tproviderName: "); - output.append(providerName); - output.append("\n"); - output.append("\tbackground: "); - output.append(background); - output.append("\n"); - output.append("\tlogo: "); - output.append(logo); - output.append("\n"); - output.append("\tprogressBar: "); - output.append(progressBar); - output.append("\n"); - output.append("\tsplash: "); - output.append(splash); - output.append("\n"); - output.append("\twaterMark: "); - output.append(waterMark); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class DescriptorClusterDeviceType { - public Long type; - public Integer revision; - - public DescriptorClusterDeviceType(Long type, Integer revision) { - this.type = type; - this.revision = revision; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DescriptorClusterDeviceType {\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\trevision: "); - output.append(revision); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class DoorLockClusterDlCredential { - public Integer credentialType; - public Integer credentialIndex; - - public DoorLockClusterDlCredential(Integer credentialType, Integer credentialIndex) { - this.credentialType = credentialType; - this.credentialIndex = credentialIndex; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DoorLockClusterDlCredential {\n"); - output.append("\tcredentialType: "); - output.append(credentialType); - output.append("\n"); - output.append("\tcredentialIndex: "); - output.append(credentialIndex); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class FixedLabelClusterLabelStruct { - public String label; - public String value; - - public FixedLabelClusterLabelStruct(String label, String value) { - this.label = label; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("FixedLabelClusterLabelStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class GeneralCommissioningClusterBasicCommissioningInfoType { - public Long failSafeExpiryLengthMs; - - public GeneralCommissioningClusterBasicCommissioningInfoType(Long failSafeExpiryLengthMs) { - this.failSafeExpiryLengthMs = failSafeExpiryLengthMs; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GeneralCommissioningClusterBasicCommissioningInfoType {\n"); - output.append("\tfailSafeExpiryLengthMs: "); - output.append(failSafeExpiryLengthMs); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class GeneralDiagnosticsClusterNetworkInterfaceType { - public String name; - public Boolean fabricConnected; - public Boolean offPremiseServicesReachableIPv4; - public Boolean offPremiseServicesReachableIPv6; - public byte[] hardwareAddress; - public Integer type; - - public GeneralDiagnosticsClusterNetworkInterfaceType( - String name, - Boolean fabricConnected, - Boolean offPremiseServicesReachableIPv4, - Boolean offPremiseServicesReachableIPv6, - byte[] hardwareAddress, - Integer type) { - this.name = name; - this.fabricConnected = fabricConnected; - this.offPremiseServicesReachableIPv4 = offPremiseServicesReachableIPv4; - this.offPremiseServicesReachableIPv6 = offPremiseServicesReachableIPv6; - this.hardwareAddress = hardwareAddress; - this.type = type; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GeneralDiagnosticsClusterNetworkInterfaceType {\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tfabricConnected: "); - output.append(fabricConnected); - output.append("\n"); - output.append("\toffPremiseServicesReachableIPv4: "); - output.append(offPremiseServicesReachableIPv4); - output.append("\n"); - output.append("\toffPremiseServicesReachableIPv6: "); - output.append(offPremiseServicesReachableIPv6); - output.append("\n"); - output.append("\thardwareAddress: "); - output.append(Arrays.toString(hardwareAddress)); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class GroupKeyManagementClusterGroupInfo { - public Integer fabricIndex; - public Integer groupId; - public ArrayList endpoints; - public String groupName; - - public GroupKeyManagementClusterGroupInfo( - Integer fabricIndex, Integer groupId, ArrayList endpoints, String groupName) { - this.fabricIndex = fabricIndex; - this.groupId = groupId; - this.endpoints = endpoints; - this.groupName = groupName; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupInfo {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tgroupId: "); - output.append(groupId); - output.append("\n"); - output.append("\tendpoints: "); - output.append(endpoints); - output.append("\n"); - output.append("\tgroupName: "); - output.append(groupName); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class GroupKeyManagementClusterGroupKey { - public Integer fabricIndex; - public Integer groupId; - public Integer groupKeySetID; - - public GroupKeyManagementClusterGroupKey( - Integer fabricIndex, Integer groupId, Integer groupKeySetID) { - this.fabricIndex = fabricIndex; - this.groupId = groupId; - this.groupKeySetID = groupKeySetID; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupKey {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tgroupId: "); - output.append(groupId); - output.append("\n"); - output.append("\tgroupKeySetID: "); - output.append(groupKeySetID); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class GroupKeyManagementClusterGroupKeySet { - public Integer groupKeySetID; - public Integer securityPolicy; - public byte[] epochKey0; - public Long epochStartTime0; - public byte[] epochKey1; - public Long epochStartTime1; - public byte[] epochKey2; - public Long epochStartTime2; - - public GroupKeyManagementClusterGroupKeySet( - Integer groupKeySetID, - Integer securityPolicy, - byte[] epochKey0, - Long epochStartTime0, - byte[] epochKey1, - Long epochStartTime1, - byte[] epochKey2, - Long epochStartTime2) { - this.groupKeySetID = groupKeySetID; - this.securityPolicy = securityPolicy; - this.epochKey0 = epochKey0; - this.epochStartTime0 = epochStartTime0; - this.epochKey1 = epochKey1; - this.epochStartTime1 = epochStartTime1; - this.epochKey2 = epochKey2; - this.epochStartTime2 = epochStartTime2; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupKeySet {\n"); - output.append("\tgroupKeySetID: "); - output.append(groupKeySetID); - output.append("\n"); - output.append("\tsecurityPolicy: "); - output.append(securityPolicy); - output.append("\n"); - output.append("\tepochKey0: "); - output.append(Arrays.toString(epochKey0)); - output.append("\n"); - output.append("\tepochStartTime0: "); - output.append(epochStartTime0); - output.append("\n"); - output.append("\tepochKey1: "); - output.append(Arrays.toString(epochKey1)); - output.append("\n"); - output.append("\tepochStartTime1: "); - output.append(epochStartTime1); - output.append("\n"); - output.append("\tepochKey2: "); - output.append(Arrays.toString(epochKey2)); - output.append("\n"); - output.append("\tepochStartTime2: "); - output.append(epochStartTime2); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class MediaInputClusterInputInfo { - public Integer index; - public Integer inputType; - public String name; - public String description; - - public MediaInputClusterInputInfo( - Integer index, Integer inputType, String name, String description) { - this.index = index; - this.inputType = inputType; - this.name = name; - this.description = description; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("MediaInputClusterInputInfo {\n"); - output.append("\tindex: "); - output.append(index); - output.append("\n"); - output.append("\tinputType: "); - output.append(inputType); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tdescription: "); - output.append(description); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class MediaPlaybackClusterPlaybackPosition { - public Long updatedAt; - public Long position; - - public MediaPlaybackClusterPlaybackPosition(Long updatedAt, Long position) { - this.updatedAt = updatedAt; - this.position = position; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("MediaPlaybackClusterPlaybackPosition {\n"); - output.append("\tupdatedAt: "); - output.append(updatedAt); - output.append("\n"); - output.append("\tposition: "); - output.append(position); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ModeSelectClusterModeOptionStruct { - public String label; - public Integer mode; - public Long semanticTag; - - public ModeSelectClusterModeOptionStruct(String label, Integer mode, Long semanticTag) { - this.label = label; - this.mode = mode; - this.semanticTag = semanticTag; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ModeSelectClusterModeOptionStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tmode: "); - output.append(mode); - output.append("\n"); - output.append("\tsemanticTag: "); - output.append(semanticTag); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ModeSelectClusterSemanticTag { - public Integer mfgCode; - public Integer value; - - public ModeSelectClusterSemanticTag(Integer mfgCode, Integer value) { - this.mfgCode = mfgCode; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ModeSelectClusterSemanticTag {\n"); - output.append("\tmfgCode: "); - output.append(mfgCode); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class NetworkCommissioningClusterNetworkInfo { - public byte[] networkID; - public Boolean connected; - - public NetworkCommissioningClusterNetworkInfo(byte[] networkID, Boolean connected) { - this.networkID = networkID; - this.connected = connected; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterNetworkInfo {\n"); - output.append("\tnetworkID: "); - output.append(Arrays.toString(networkID)); - output.append("\n"); - output.append("\tconnected: "); - output.append(connected); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class NetworkCommissioningClusterThreadInterfaceScanResult { - public Long panId; - public Long extendedPanId; - public String networkName; - public Integer channel; - public Integer version; - public Long extendedAddress; - public Integer rssi; - public Integer lqi; - - public NetworkCommissioningClusterThreadInterfaceScanResult( - Long panId, - Long extendedPanId, - String networkName, - Integer channel, - Integer version, - Long extendedAddress, - Integer rssi, - Integer lqi) { - this.panId = panId; - this.extendedPanId = extendedPanId; - this.networkName = networkName; - this.channel = channel; - this.version = version; - this.extendedAddress = extendedAddress; - this.rssi = rssi; - this.lqi = lqi; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterThreadInterfaceScanResult {\n"); - output.append("\tpanId: "); - output.append(panId); - output.append("\n"); - output.append("\textendedPanId: "); - output.append(extendedPanId); - output.append("\n"); - output.append("\tnetworkName: "); - output.append(networkName); - output.append("\n"); - output.append("\tchannel: "); - output.append(channel); - output.append("\n"); - output.append("\tversion: "); - output.append(version); - output.append("\n"); - output.append("\textendedAddress: "); - output.append(extendedAddress); - output.append("\n"); - output.append("\trssi: "); - output.append(rssi); - output.append("\n"); - output.append("\tlqi: "); - output.append(lqi); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class NetworkCommissioningClusterWiFiInterfaceScanResult { - public Integer security; - public byte[] ssid; - public byte[] bssid; - public Integer channel; - public Integer wiFiBand; - public Integer rssi; - - public NetworkCommissioningClusterWiFiInterfaceScanResult( - Integer security, - byte[] ssid, - byte[] bssid, - Integer channel, - Integer wiFiBand, - Integer rssi) { - this.security = security; - this.ssid = ssid; - this.bssid = bssid; - this.channel = channel; - this.wiFiBand = wiFiBand; - this.rssi = rssi; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterWiFiInterfaceScanResult {\n"); - output.append("\tsecurity: "); - output.append(security); - output.append("\n"); - output.append("\tssid: "); - output.append(Arrays.toString(ssid)); - output.append("\n"); - output.append("\tbssid: "); - output.append(Arrays.toString(bssid)); - output.append("\n"); - output.append("\tchannel: "); - output.append(channel); - output.append("\n"); - output.append("\twiFiBand: "); - output.append(wiFiBand); - output.append("\n"); - output.append("\trssi: "); - output.append(rssi); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class OtaSoftwareUpdateRequestorClusterProviderLocation { - public Integer fabricIndex; - public Long providerNodeID; - public Integer endpoint; - - public OtaSoftwareUpdateRequestorClusterProviderLocation( - Integer fabricIndex, Long providerNodeID, Integer endpoint) { - this.fabricIndex = fabricIndex; - this.providerNodeID = providerNodeID; - this.endpoint = endpoint; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OtaSoftwareUpdateRequestorClusterProviderLocation {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tproviderNodeID: "); - output.append(providerNodeID); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class OperationalCredentialsClusterFabricDescriptor { - public Integer fabricIndex; - public byte[] rootPublicKey; - public Integer vendorId; - public Long fabricId; - public Long nodeId; - public String label; - - public OperationalCredentialsClusterFabricDescriptor( - Integer fabricIndex, - byte[] rootPublicKey, - Integer vendorId, - Long fabricId, - Long nodeId, - String label) { - this.fabricIndex = fabricIndex; - this.rootPublicKey = rootPublicKey; - this.vendorId = vendorId; - this.fabricId = fabricId; - this.nodeId = nodeId; - this.label = label; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OperationalCredentialsClusterFabricDescriptor {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\trootPublicKey: "); - output.append(Arrays.toString(rootPublicKey)); - output.append("\n"); - output.append("\tvendorId: "); - output.append(vendorId); - output.append("\n"); - output.append("\tfabricId: "); - output.append(fabricId); - output.append("\n"); - output.append("\tnodeId: "); - output.append(nodeId); - output.append("\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class OperationalCredentialsClusterNOCStruct { - public Integer fabricIndex; - public byte[] noc; - public @Nullable byte[] icac; - - public OperationalCredentialsClusterNOCStruct( - Integer fabricIndex, byte[] noc, @Nullable byte[] icac) { - this.fabricIndex = fabricIndex; - this.noc = noc; - this.icac = icac; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OperationalCredentialsClusterNOCStruct {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tnoc: "); - output.append(Arrays.toString(noc)); - output.append("\n"); - output.append("\ticac: "); - output.append(Arrays.toString(icac)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class PowerSourceClusterBatChargeFaultChangeType { - public ArrayList current; - public ArrayList previous; - - public PowerSourceClusterBatChargeFaultChangeType( - ArrayList current, ArrayList previous) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterBatChargeFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class PowerSourceClusterBatFaultChangeType { - public ArrayList current; - public ArrayList previous; - - public PowerSourceClusterBatFaultChangeType( - ArrayList current, ArrayList previous) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterBatFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class PowerSourceClusterWiredFaultChangeType { - public ArrayList current; - public ArrayList previous; - - public PowerSourceClusterWiredFaultChangeType( - ArrayList current, ArrayList previous) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterWiredFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ScenesClusterSceneExtensionFieldSet { - public Long clusterId; - public Integer length; - public Integer value; - - public ScenesClusterSceneExtensionFieldSet(Long clusterId, Integer length, Integer value) { - this.clusterId = clusterId; - this.length = length; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ScenesClusterSceneExtensionFieldSet {\n"); - output.append("\tclusterId: "); - output.append(clusterId); - output.append("\n"); - output.append("\tlength: "); - output.append(length); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class SoftwareDiagnosticsClusterSoftwareFaultStruct { - public Long id; - public String name; - public byte[] faultRecording; - - public SoftwareDiagnosticsClusterSoftwareFaultStruct( - Long id, String name, byte[] faultRecording) { - this.id = id; - this.name = name; - this.faultRecording = faultRecording; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SoftwareDiagnosticsClusterSoftwareFaultStruct {\n"); - output.append("\tid: "); - output.append(id); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tfaultRecording: "); - output.append(Arrays.toString(faultRecording)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class SoftwareDiagnosticsClusterThreadMetrics { - public Long id; - public String name; - public Long stackFreeCurrent; - public Long stackFreeMinimum; - public Long stackSize; - - public SoftwareDiagnosticsClusterThreadMetrics( - Long id, String name, Long stackFreeCurrent, Long stackFreeMinimum, Long stackSize) { - this.id = id; - this.name = name; - this.stackFreeCurrent = stackFreeCurrent; - this.stackFreeMinimum = stackFreeMinimum; - this.stackSize = stackSize; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SoftwareDiagnosticsClusterThreadMetrics {\n"); - output.append("\tid: "); - output.append(id); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tstackFreeCurrent: "); - output.append(stackFreeCurrent); - output.append("\n"); - output.append("\tstackFreeMinimum: "); - output.append(stackFreeMinimum); - output.append("\n"); - output.append("\tstackSize: "); - output.append(stackSize); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TargetNavigatorClusterTargetInfo { - public Integer identifier; - public String name; - - public TargetNavigatorClusterTargetInfo(Integer identifier, String name) { - this.identifier = identifier; - this.name = name; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TargetNavigatorClusterTargetInfo {\n"); - output.append("\tidentifier: "); - output.append(identifier); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterSimpleStruct { - public Integer a; - public Boolean b; - public Integer c; - public byte[] d; - public String e; - public Integer f; - public Float g; - public Double h; - - public TestClusterClusterSimpleStruct( - Integer a, Boolean b, Integer c, byte[] d, String e, Integer f, Float g, Double h) { - this.a = a; - this.b = b; - this.c = c; - this.d = d; - this.e = e; - this.f = f; - this.g = g; - this.h = h; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterSimpleStruct {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("\td: "); - output.append(Arrays.toString(d)); - output.append("\n"); - output.append("\te: "); - output.append(e); - output.append("\n"); - output.append("\tf: "); - output.append(f); - output.append("\n"); - output.append("\tg: "); - output.append(g); - output.append("\n"); - output.append("\th: "); - output.append(h); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterNullablesAndOptionalsStruct { - public @Nullable Integer nullableInt; - public Optional optionalInt; - public @Nullable Optional nullableOptionalInt; - public @Nullable String nullableString; - public Optional optionalString; - public @Nullable Optional nullableOptionalString; - public @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct; - public Optional optionalStruct; - public @Nullable Optional nullableOptionalStruct; - public @Nullable ArrayList nullableList; - public Optional> optionalList; - public @Nullable Optional> nullableOptionalList; - - public TestClusterClusterNullablesAndOptionalsStruct( - @Nullable Integer nullableInt, - Optional optionalInt, - @Nullable Optional nullableOptionalInt, - @Nullable String nullableString, - Optional optionalString, - @Nullable Optional nullableOptionalString, - @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct, - Optional optionalStruct, - @Nullable Optional nullableOptionalStruct, - @Nullable ArrayList nullableList, - Optional> optionalList, - @Nullable Optional> nullableOptionalList) { - this.nullableInt = nullableInt; - this.optionalInt = optionalInt; - this.nullableOptionalInt = nullableOptionalInt; - this.nullableString = nullableString; - this.optionalString = optionalString; - this.nullableOptionalString = nullableOptionalString; - this.nullableStruct = nullableStruct; - this.optionalStruct = optionalStruct; - this.nullableOptionalStruct = nullableOptionalStruct; - this.nullableList = nullableList; - this.optionalList = optionalList; - this.nullableOptionalList = nullableOptionalList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNullablesAndOptionalsStruct {\n"); - output.append("\tnullableInt: "); - output.append(nullableInt); - output.append("\n"); - output.append("\toptionalInt: "); - output.append(optionalInt); - output.append("\n"); - output.append("\tnullableOptionalInt: "); - output.append(nullableOptionalInt); - output.append("\n"); - output.append("\tnullableString: "); - output.append(nullableString); - output.append("\n"); - output.append("\toptionalString: "); - output.append(optionalString); - output.append("\n"); - output.append("\tnullableOptionalString: "); - output.append(nullableOptionalString); - output.append("\n"); - output.append("\tnullableStruct: "); - output.append(nullableStruct); - output.append("\n"); - output.append("\toptionalStruct: "); - output.append(optionalStruct); - output.append("\n"); - output.append("\tnullableOptionalStruct: "); - output.append(nullableOptionalStruct); - output.append("\n"); - output.append("\tnullableList: "); - output.append(nullableList); - output.append("\n"); - output.append("\toptionalList: "); - output.append(optionalList); - output.append("\n"); - output.append("\tnullableOptionalList: "); - output.append(nullableOptionalList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterNestedStruct { - public Integer a; - public Boolean b; - public ChipStructs.TestClusterClusterSimpleStruct c; - - public TestClusterClusterNestedStruct( - Integer a, Boolean b, ChipStructs.TestClusterClusterSimpleStruct c) { - this.a = a; - this.b = b; - this.c = c; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNestedStruct {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterNestedStructList { - public Integer a; - public Boolean b; - public ChipStructs.TestClusterClusterSimpleStruct c; - public ArrayList d; - public ArrayList e; - public ArrayList f; - public ArrayList g; - - public TestClusterClusterNestedStructList( - Integer a, - Boolean b, - ChipStructs.TestClusterClusterSimpleStruct c, - ArrayList d, - ArrayList e, - ArrayList f, - ArrayList g) { - this.a = a; - this.b = b; - this.c = c; - this.d = d; - this.e = e; - this.f = f; - this.g = g; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNestedStructList {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("\td: "); - output.append(d); - output.append("\n"); - output.append("\te: "); - output.append(e); - output.append("\n"); - output.append("\tf: "); - output.append(f); - output.append("\n"); - output.append("\tg: "); - output.append(g); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterDoubleNestedStructList { - public ArrayList a; - - public TestClusterClusterDoubleNestedStructList( - ArrayList a) { - this.a = a; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterDoubleNestedStructList {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterTestFabricScoped { - public Integer fabricIndex; - - public TestClusterClusterTestFabricScoped(Integer fabricIndex) { - this.fabricIndex = fabricIndex; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterTestFabricScoped {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class TestClusterClusterTestListStructOctet { - public Long fabricIndex; - public byte[] operationalCert; - - public TestClusterClusterTestListStructOctet(Long fabricIndex, byte[] operationalCert) { - this.fabricIndex = fabricIndex; - this.operationalCert = operationalCert; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterTestListStructOctet {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\toperationalCert: "); - output.append(Arrays.toString(operationalCert)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ThreadNetworkDiagnosticsClusterNeighborTable { - public Long extAddress; - public Long age; - public Integer rloc16; - public Long linkFrameCounter; - public Long mleFrameCounter; - public Integer lqi; - public Integer averageRssi; - public Integer lastRssi; - public Integer frameErrorRate; - public Integer messageErrorRate; - public Boolean rxOnWhenIdle; - public Boolean fullThreadDevice; - public Boolean fullNetworkData; - public Boolean isChild; - - public ThreadNetworkDiagnosticsClusterNeighborTable( - Long extAddress, - Long age, - Integer rloc16, - Long linkFrameCounter, - Long mleFrameCounter, - Integer lqi, - Integer averageRssi, - Integer lastRssi, - Integer frameErrorRate, - Integer messageErrorRate, - Boolean rxOnWhenIdle, - Boolean fullThreadDevice, - Boolean fullNetworkData, - Boolean isChild) { - this.extAddress = extAddress; - this.age = age; - this.rloc16 = rloc16; - this.linkFrameCounter = linkFrameCounter; - this.mleFrameCounter = mleFrameCounter; - this.lqi = lqi; - this.averageRssi = averageRssi; - this.lastRssi = lastRssi; - this.frameErrorRate = frameErrorRate; - this.messageErrorRate = messageErrorRate; - this.rxOnWhenIdle = rxOnWhenIdle; - this.fullThreadDevice = fullThreadDevice; - this.fullNetworkData = fullNetworkData; - this.isChild = isChild; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterNeighborTable {\n"); - output.append("\textAddress: "); - output.append(extAddress); - output.append("\n"); - output.append("\tage: "); - output.append(age); - output.append("\n"); - output.append("\trloc16: "); - output.append(rloc16); - output.append("\n"); - output.append("\tlinkFrameCounter: "); - output.append(linkFrameCounter); - output.append("\n"); - output.append("\tmleFrameCounter: "); - output.append(mleFrameCounter); - output.append("\n"); - output.append("\tlqi: "); - output.append(lqi); - output.append("\n"); - output.append("\taverageRssi: "); - output.append(averageRssi); - output.append("\n"); - output.append("\tlastRssi: "); - output.append(lastRssi); - output.append("\n"); - output.append("\tframeErrorRate: "); - output.append(frameErrorRate); - output.append("\n"); - output.append("\tmessageErrorRate: "); - output.append(messageErrorRate); - output.append("\n"); - output.append("\trxOnWhenIdle: "); - output.append(rxOnWhenIdle); - output.append("\n"); - output.append("\tfullThreadDevice: "); - output.append(fullThreadDevice); - output.append("\n"); - output.append("\tfullNetworkData: "); - output.append(fullNetworkData); - output.append("\n"); - output.append("\tisChild: "); - output.append(isChild); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ThreadNetworkDiagnosticsClusterOperationalDatasetComponents { - public Boolean activeTimestampPresent; - public Boolean pendingTimestampPresent; - public Boolean masterKeyPresent; - public Boolean networkNamePresent; - public Boolean extendedPanIdPresent; - public Boolean meshLocalPrefixPresent; - public Boolean delayPresent; - public Boolean panIdPresent; - public Boolean channelPresent; - public Boolean pskcPresent; - public Boolean securityPolicyPresent; - public Boolean channelMaskPresent; - - public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents( - Boolean activeTimestampPresent, - Boolean pendingTimestampPresent, - Boolean masterKeyPresent, - Boolean networkNamePresent, - Boolean extendedPanIdPresent, - Boolean meshLocalPrefixPresent, - Boolean delayPresent, - Boolean panIdPresent, - Boolean channelPresent, - Boolean pskcPresent, - Boolean securityPolicyPresent, - Boolean channelMaskPresent) { - this.activeTimestampPresent = activeTimestampPresent; - this.pendingTimestampPresent = pendingTimestampPresent; - this.masterKeyPresent = masterKeyPresent; - this.networkNamePresent = networkNamePresent; - this.extendedPanIdPresent = extendedPanIdPresent; - this.meshLocalPrefixPresent = meshLocalPrefixPresent; - this.delayPresent = delayPresent; - this.panIdPresent = panIdPresent; - this.channelPresent = channelPresent; - this.pskcPresent = pskcPresent; - this.securityPolicyPresent = securityPolicyPresent; - this.channelMaskPresent = channelMaskPresent; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterOperationalDatasetComponents {\n"); - output.append("\tactiveTimestampPresent: "); - output.append(activeTimestampPresent); - output.append("\n"); - output.append("\tpendingTimestampPresent: "); - output.append(pendingTimestampPresent); - output.append("\n"); - output.append("\tmasterKeyPresent: "); - output.append(masterKeyPresent); - output.append("\n"); - output.append("\tnetworkNamePresent: "); - output.append(networkNamePresent); - output.append("\n"); - output.append("\textendedPanIdPresent: "); - output.append(extendedPanIdPresent); - output.append("\n"); - output.append("\tmeshLocalPrefixPresent: "); - output.append(meshLocalPrefixPresent); - output.append("\n"); - output.append("\tdelayPresent: "); - output.append(delayPresent); - output.append("\n"); - output.append("\tpanIdPresent: "); - output.append(panIdPresent); - output.append("\n"); - output.append("\tchannelPresent: "); - output.append(channelPresent); - output.append("\n"); - output.append("\tpskcPresent: "); - output.append(pskcPresent); - output.append("\n"); - output.append("\tsecurityPolicyPresent: "); - output.append(securityPolicyPresent); - output.append("\n"); - output.append("\tchannelMaskPresent: "); - output.append(channelMaskPresent); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ThreadNetworkDiagnosticsClusterRouteTable { - public Long extAddress; - public Integer rloc16; - public Integer routerId; - public Integer nextHop; - public Integer pathCost; - public Integer LQIIn; - public Integer LQIOut; - public Integer age; - public Boolean allocated; - public Boolean linkEstablished; - - public ThreadNetworkDiagnosticsClusterRouteTable( - Long extAddress, - Integer rloc16, - Integer routerId, - Integer nextHop, - Integer pathCost, - Integer LQIIn, - Integer LQIOut, - Integer age, - Boolean allocated, - Boolean linkEstablished) { - this.extAddress = extAddress; - this.rloc16 = rloc16; - this.routerId = routerId; - this.nextHop = nextHop; - this.pathCost = pathCost; - this.LQIIn = LQIIn; - this.LQIOut = LQIOut; - this.age = age; - this.allocated = allocated; - this.linkEstablished = linkEstablished; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterRouteTable {\n"); - output.append("\textAddress: "); - output.append(extAddress); - output.append("\n"); - output.append("\trloc16: "); - output.append(rloc16); - output.append("\n"); - output.append("\trouterId: "); - output.append(routerId); - output.append("\n"); - output.append("\tnextHop: "); - output.append(nextHop); - output.append("\n"); - output.append("\tpathCost: "); - output.append(pathCost); - output.append("\n"); - output.append("\tLQIIn: "); - output.append(LQIIn); - output.append("\n"); - output.append("\tLQIOut: "); - output.append(LQIOut); - output.append("\n"); - output.append("\tage: "); - output.append(age); - output.append("\n"); - output.append("\tallocated: "); - output.append(allocated); - output.append("\n"); - output.append("\tlinkEstablished: "); - output.append(linkEstablished); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class ThreadNetworkDiagnosticsClusterSecurityPolicy { - public Integer rotationTime; - public Integer flags; - - public ThreadNetworkDiagnosticsClusterSecurityPolicy(Integer rotationTime, Integer flags) { - this.rotationTime = rotationTime; - this.flags = flags; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterSecurityPolicy {\n"); - output.append("\trotationTime: "); - output.append(rotationTime); - output.append("\n"); - output.append("\tflags: "); - output.append(flags); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } - } - - public static class UserLabelClusterLabelStruct { - public String label; - public String value; - - public UserLabelClusterLabelStruct(String label, String value) { - this.label = label; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("UserLabelClusterLabelStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } +public static class AccessControlClusterTarget { +public @Nullable Long cluster; +public @Nullable Integer endpoint; +public @Nullable Long deviceType; + + public AccessControlClusterTarget( + @Nullable Long cluster + , @Nullable Integer endpoint + , @Nullable Long deviceType + ) { + this.cluster = cluster; + this.endpoint = endpoint; + this.deviceType = deviceType; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterTarget {\n"); + output.append("\tcluster: "); + output.append(cluster); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("\tdeviceType: "); + output.append(deviceType); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class AccessControlClusterAccessControlEntry { +public Integer fabricIndex; +public Integer privilege; +public Integer authMode; +public @Nullable ArrayList subjects; +public @Nullable ArrayList targets; + + public AccessControlClusterAccessControlEntry( + Integer fabricIndex + , Integer privilege + , Integer authMode + , @Nullable ArrayList subjects + , @Nullable ArrayList targets + ) { + this.fabricIndex = fabricIndex; + this.privilege = privilege; + this.authMode = authMode; + this.subjects = subjects; + this.targets = targets; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterAccessControlEntry {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tprivilege: "); + output.append(privilege); + output.append("\n"); + output.append("\tauthMode: "); + output.append(authMode); + output.append("\n"); + output.append("\tsubjects: "); + output.append(subjects); + output.append("\n"); + output.append("\ttargets: "); + output.append(targets); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class AccessControlClusterExtensionEntry { +public Integer fabricIndex; +public byte[] data; + + public AccessControlClusterExtensionEntry( + Integer fabricIndex + , byte[] data + ) { + this.fabricIndex = fabricIndex; + this.data = data; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterExtensionEntry {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tdata: "); + output.append(Arrays.toString(data)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ApplicationBasicClusterApplicationBasicApplication { +public Integer catalogVendorId; +public String applicationId; + + public ApplicationBasicClusterApplicationBasicApplication( + Integer catalogVendorId + , String applicationId + ) { + this.catalogVendorId = catalogVendorId; + this.applicationId = applicationId; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationBasicClusterApplicationBasicApplication {\n"); + output.append("\tcatalogVendorId: "); + output.append(catalogVendorId); + output.append("\n"); + output.append("\tapplicationId: "); + output.append(applicationId); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ApplicationLauncherClusterApplicationLauncherApplication { +public Integer catalogVendorId; +public String applicationId; + + public ApplicationLauncherClusterApplicationLauncherApplication( + Integer catalogVendorId + , String applicationId + ) { + this.catalogVendorId = catalogVendorId; + this.applicationId = applicationId; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationLauncherClusterApplicationLauncherApplication {\n"); + output.append("\tcatalogVendorId: "); + output.append(catalogVendorId); + output.append("\n"); + output.append("\tapplicationId: "); + output.append(applicationId); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ApplicationLauncherClusterApplicationEP { +public ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application; +public String endpoint; + + public ApplicationLauncherClusterApplicationEP( + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application + , String endpoint + ) { + this.application = application; + this.endpoint = endpoint; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationLauncherClusterApplicationEP {\n"); + output.append("\tapplication: "); + output.append(application); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class AudioOutputClusterOutputInfo { +public Integer index; +public Integer outputType; +public String name; + + public AudioOutputClusterOutputInfo( + Integer index + , Integer outputType + , String name + ) { + this.index = index; + this.outputType = outputType; + this.name = name; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AudioOutputClusterOutputInfo {\n"); + output.append("\tindex: "); + output.append(index); + output.append("\n"); + output.append("\toutputType: "); + output.append(outputType); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class BridgedActionsClusterActionStruct { +public Integer actionID; +public String name; +public Integer type; +public Integer endpointListID; +public Integer supportedCommands; +public Integer status; + + public BridgedActionsClusterActionStruct( + Integer actionID + , String name + , Integer type + , Integer endpointListID + , Integer supportedCommands + , Integer status + ) { + this.actionID = actionID; + this.name = name; + this.type = type; + this.endpointListID = endpointListID; + this.supportedCommands = supportedCommands; + this.status = status; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedActionsClusterActionStruct {\n"); + output.append("\tactionID: "); + output.append(actionID); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tendpointListID: "); + output.append(endpointListID); + output.append("\n"); + output.append("\tsupportedCommands: "); + output.append(supportedCommands); + output.append("\n"); + output.append("\tstatus: "); + output.append(status); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class BridgedActionsClusterEndpointListStruct { +public Integer endpointListID; +public String name; +public Integer type; +public ArrayList endpoints; + + public BridgedActionsClusterEndpointListStruct( + Integer endpointListID + , String name + , Integer type + , ArrayList endpoints + ) { + this.endpointListID = endpointListID; + this.name = name; + this.type = type; + this.endpoints = endpoints; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedActionsClusterEndpointListStruct {\n"); + output.append("\tendpointListID: "); + output.append(endpointListID); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tendpoints: "); + output.append(endpoints); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ChannelClusterChannelInfo { +public Integer majorNumber; +public Integer minorNumber; +public String name; +public String callSign; +public String affiliateCallSign; + + public ChannelClusterChannelInfo( + Integer majorNumber + , Integer minorNumber + , String name + , String callSign + , String affiliateCallSign + ) { + this.majorNumber = majorNumber; + this.minorNumber = minorNumber; + this.name = name; + this.callSign = callSign; + this.affiliateCallSign = affiliateCallSign; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ChannelClusterChannelInfo {\n"); + output.append("\tmajorNumber: "); + output.append(majorNumber); + output.append("\n"); + output.append("\tminorNumber: "); + output.append(minorNumber); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tcallSign: "); + output.append(callSign); + output.append("\n"); + output.append("\taffiliateCallSign: "); + output.append(affiliateCallSign); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ChannelClusterLineupInfo { +public String operatorName; +public String lineupName; +public String postalCode; +public Integer lineupInfoType; + + public ChannelClusterLineupInfo( + String operatorName + , String lineupName + , String postalCode + , Integer lineupInfoType + ) { + this.operatorName = operatorName; + this.lineupName = lineupName; + this.postalCode = postalCode; + this.lineupInfoType = lineupInfoType; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ChannelClusterLineupInfo {\n"); + output.append("\toperatorName: "); + output.append(operatorName); + output.append("\n"); + output.append("\tlineupName: "); + output.append(lineupName); + output.append("\n"); + output.append("\tpostalCode: "); + output.append(postalCode); + output.append("\n"); + output.append("\tlineupInfoType: "); + output.append(lineupInfoType); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterDimension { +public Double width; +public Double height; +public Integer metric; + + public ContentLauncherClusterDimension( + Double width + , Double height + , Integer metric + ) { + this.width = width; + this.height = height; + this.metric = metric; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterDimension {\n"); + output.append("\twidth: "); + output.append(width); + output.append("\n"); + output.append("\theight: "); + output.append(height); + output.append("\n"); + output.append("\tmetric: "); + output.append(metric); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterAdditionalInfo { +public String name; +public String value; + + public ContentLauncherClusterAdditionalInfo( + String name + , String value + ) { + this.name = name; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterAdditionalInfo {\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterParameter { +public Integer type; +public String value; +public ArrayList externalIDList; + + public ContentLauncherClusterParameter( + Integer type + , String value + , ArrayList externalIDList + ) { + this.type = type; + this.value = value; + this.externalIDList = externalIDList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterParameter {\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("\texternalIDList: "); + output.append(externalIDList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterContentSearch { +public ArrayList parameterList; + + public ContentLauncherClusterContentSearch( + ArrayList parameterList + ) { + this.parameterList = parameterList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterContentSearch {\n"); + output.append("\tparameterList: "); + output.append(parameterList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterStyleInformation { +public String imageUrl; +public String color; +public ChipStructs.ContentLauncherClusterDimension size; + + public ContentLauncherClusterStyleInformation( + String imageUrl + , String color + , ChipStructs.ContentLauncherClusterDimension size + ) { + this.imageUrl = imageUrl; + this.color = color; + this.size = size; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterStyleInformation {\n"); + output.append("\timageUrl: "); + output.append(imageUrl); + output.append("\n"); + output.append("\tcolor: "); + output.append(color); + output.append("\n"); + output.append("\tsize: "); + output.append(size); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ContentLauncherClusterBrandingInformation { +public String providerName; +public ChipStructs.ContentLauncherClusterStyleInformation background; +public ChipStructs.ContentLauncherClusterStyleInformation logo; +public ChipStructs.ContentLauncherClusterStyleInformation progressBar; +public ChipStructs.ContentLauncherClusterStyleInformation splash; +public ChipStructs.ContentLauncherClusterStyleInformation waterMark; + + public ContentLauncherClusterBrandingInformation( + String providerName + , ChipStructs.ContentLauncherClusterStyleInformation background + , ChipStructs.ContentLauncherClusterStyleInformation logo + , ChipStructs.ContentLauncherClusterStyleInformation progressBar + , ChipStructs.ContentLauncherClusterStyleInformation splash + , ChipStructs.ContentLauncherClusterStyleInformation waterMark + ) { + this.providerName = providerName; + this.background = background; + this.logo = logo; + this.progressBar = progressBar; + this.splash = splash; + this.waterMark = waterMark; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterBrandingInformation {\n"); + output.append("\tproviderName: "); + output.append(providerName); + output.append("\n"); + output.append("\tbackground: "); + output.append(background); + output.append("\n"); + output.append("\tlogo: "); + output.append(logo); + output.append("\n"); + output.append("\tprogressBar: "); + output.append(progressBar); + output.append("\n"); + output.append("\tsplash: "); + output.append(splash); + output.append("\n"); + output.append("\twaterMark: "); + output.append(waterMark); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class DescriptorClusterDeviceType { +public Long type; +public Integer revision; + + public DescriptorClusterDeviceType( + Long type + , Integer revision + ) { + this.type = type; + this.revision = revision; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DescriptorClusterDeviceType {\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\trevision: "); + output.append(revision); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class DoorLockClusterDlCredential { +public Integer credentialType; +public Integer credentialIndex; + + public DoorLockClusterDlCredential( + Integer credentialType + , Integer credentialIndex + ) { + this.credentialType = credentialType; + this.credentialIndex = credentialIndex; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DoorLockClusterDlCredential {\n"); + output.append("\tcredentialType: "); + output.append(credentialType); + output.append("\n"); + output.append("\tcredentialIndex: "); + output.append(credentialIndex); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class FixedLabelClusterLabelStruct { +public String label; +public String value; + + public FixedLabelClusterLabelStruct( + String label + , String value + ) { + this.label = label; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("FixedLabelClusterLabelStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class GeneralCommissioningClusterBasicCommissioningInfoType { +public Long failSafeExpiryLengthMs; + + public GeneralCommissioningClusterBasicCommissioningInfoType( + Long failSafeExpiryLengthMs + ) { + this.failSafeExpiryLengthMs = failSafeExpiryLengthMs; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GeneralCommissioningClusterBasicCommissioningInfoType {\n"); + output.append("\tfailSafeExpiryLengthMs: "); + output.append(failSafeExpiryLengthMs); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class GeneralDiagnosticsClusterNetworkInterfaceType { +public String name; +public Boolean fabricConnected; +public Boolean offPremiseServicesReachableIPv4; +public Boolean offPremiseServicesReachableIPv6; +public byte[] hardwareAddress; +public Integer type; + + public GeneralDiagnosticsClusterNetworkInterfaceType( + String name + , Boolean fabricConnected + , Boolean offPremiseServicesReachableIPv4 + , Boolean offPremiseServicesReachableIPv6 + , byte[] hardwareAddress + , Integer type + ) { + this.name = name; + this.fabricConnected = fabricConnected; + this.offPremiseServicesReachableIPv4 = offPremiseServicesReachableIPv4; + this.offPremiseServicesReachableIPv6 = offPremiseServicesReachableIPv6; + this.hardwareAddress = hardwareAddress; + this.type = type; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GeneralDiagnosticsClusterNetworkInterfaceType {\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tfabricConnected: "); + output.append(fabricConnected); + output.append("\n"); + output.append("\toffPremiseServicesReachableIPv4: "); + output.append(offPremiseServicesReachableIPv4); + output.append("\n"); + output.append("\toffPremiseServicesReachableIPv6: "); + output.append(offPremiseServicesReachableIPv6); + output.append("\n"); + output.append("\thardwareAddress: "); + output.append(Arrays.toString(hardwareAddress)); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class GroupKeyManagementClusterGroupInfo { +public Integer fabricIndex; +public Integer groupId; +public ArrayList endpoints; +public String groupName; + + public GroupKeyManagementClusterGroupInfo( + Integer fabricIndex + , Integer groupId + , ArrayList endpoints + , String groupName + ) { + this.fabricIndex = fabricIndex; + this.groupId = groupId; + this.endpoints = endpoints; + this.groupName = groupName; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupInfo {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tgroupId: "); + output.append(groupId); + output.append("\n"); + output.append("\tendpoints: "); + output.append(endpoints); + output.append("\n"); + output.append("\tgroupName: "); + output.append(groupName); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class GroupKeyManagementClusterGroupKey { +public Integer fabricIndex; +public Integer groupId; +public Integer groupKeySetID; + + public GroupKeyManagementClusterGroupKey( + Integer fabricIndex + , Integer groupId + , Integer groupKeySetID + ) { + this.fabricIndex = fabricIndex; + this.groupId = groupId; + this.groupKeySetID = groupKeySetID; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupKey {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tgroupId: "); + output.append(groupId); + output.append("\n"); + output.append("\tgroupKeySetID: "); + output.append(groupKeySetID); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class GroupKeyManagementClusterGroupKeySet { +public Integer groupKeySetID; +public Integer securityPolicy; +public byte[] epochKey0; +public Long epochStartTime0; +public byte[] epochKey1; +public Long epochStartTime1; +public byte[] epochKey2; +public Long epochStartTime2; + + public GroupKeyManagementClusterGroupKeySet( + Integer groupKeySetID + , Integer securityPolicy + , byte[] epochKey0 + , Long epochStartTime0 + , byte[] epochKey1 + , Long epochStartTime1 + , byte[] epochKey2 + , Long epochStartTime2 + ) { + this.groupKeySetID = groupKeySetID; + this.securityPolicy = securityPolicy; + this.epochKey0 = epochKey0; + this.epochStartTime0 = epochStartTime0; + this.epochKey1 = epochKey1; + this.epochStartTime1 = epochStartTime1; + this.epochKey2 = epochKey2; + this.epochStartTime2 = epochStartTime2; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupKeySet {\n"); + output.append("\tgroupKeySetID: "); + output.append(groupKeySetID); + output.append("\n"); + output.append("\tsecurityPolicy: "); + output.append(securityPolicy); + output.append("\n"); + output.append("\tepochKey0: "); + output.append(Arrays.toString(epochKey0)); + output.append("\n"); + output.append("\tepochStartTime0: "); + output.append(epochStartTime0); + output.append("\n"); + output.append("\tepochKey1: "); + output.append(Arrays.toString(epochKey1)); + output.append("\n"); + output.append("\tepochStartTime1: "); + output.append(epochStartTime1); + output.append("\n"); + output.append("\tepochKey2: "); + output.append(Arrays.toString(epochKey2)); + output.append("\n"); + output.append("\tepochStartTime2: "); + output.append(epochStartTime2); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class MediaInputClusterInputInfo { +public Integer index; +public Integer inputType; +public String name; +public String description; + + public MediaInputClusterInputInfo( + Integer index + , Integer inputType + , String name + , String description + ) { + this.index = index; + this.inputType = inputType; + this.name = name; + this.description = description; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("MediaInputClusterInputInfo {\n"); + output.append("\tindex: "); + output.append(index); + output.append("\n"); + output.append("\tinputType: "); + output.append(inputType); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tdescription: "); + output.append(description); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class MediaPlaybackClusterPlaybackPosition { +public Long updatedAt; +public Long position; + + public MediaPlaybackClusterPlaybackPosition( + Long updatedAt + , Long position + ) { + this.updatedAt = updatedAt; + this.position = position; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("MediaPlaybackClusterPlaybackPosition {\n"); + output.append("\tupdatedAt: "); + output.append(updatedAt); + output.append("\n"); + output.append("\tposition: "); + output.append(position); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ModeSelectClusterModeOptionStruct { +public String label; +public Integer mode; +public Long semanticTag; + + public ModeSelectClusterModeOptionStruct( + String label + , Integer mode + , Long semanticTag + ) { + this.label = label; + this.mode = mode; + this.semanticTag = semanticTag; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ModeSelectClusterModeOptionStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tmode: "); + output.append(mode); + output.append("\n"); + output.append("\tsemanticTag: "); + output.append(semanticTag); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ModeSelectClusterSemanticTag { +public Integer mfgCode; +public Integer value; + + public ModeSelectClusterSemanticTag( + Integer mfgCode + , Integer value + ) { + this.mfgCode = mfgCode; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ModeSelectClusterSemanticTag {\n"); + output.append("\tmfgCode: "); + output.append(mfgCode); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class NetworkCommissioningClusterNetworkInfo { +public byte[] networkID; +public Boolean connected; + + public NetworkCommissioningClusterNetworkInfo( + byte[] networkID + , Boolean connected + ) { + this.networkID = networkID; + this.connected = connected; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterNetworkInfo {\n"); + output.append("\tnetworkID: "); + output.append(Arrays.toString(networkID)); + output.append("\n"); + output.append("\tconnected: "); + output.append(connected); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class NetworkCommissioningClusterThreadInterfaceScanResult { +public Long panId; +public Long extendedPanId; +public String networkName; +public Integer channel; +public Integer version; +public Long extendedAddress; +public Integer rssi; +public Integer lqi; + + public NetworkCommissioningClusterThreadInterfaceScanResult( + Long panId + , Long extendedPanId + , String networkName + , Integer channel + , Integer version + , Long extendedAddress + , Integer rssi + , Integer lqi + ) { + this.panId = panId; + this.extendedPanId = extendedPanId; + this.networkName = networkName; + this.channel = channel; + this.version = version; + this.extendedAddress = extendedAddress; + this.rssi = rssi; + this.lqi = lqi; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterThreadInterfaceScanResult {\n"); + output.append("\tpanId: "); + output.append(panId); + output.append("\n"); + output.append("\textendedPanId: "); + output.append(extendedPanId); + output.append("\n"); + output.append("\tnetworkName: "); + output.append(networkName); + output.append("\n"); + output.append("\tchannel: "); + output.append(channel); + output.append("\n"); + output.append("\tversion: "); + output.append(version); + output.append("\n"); + output.append("\textendedAddress: "); + output.append(extendedAddress); + output.append("\n"); + output.append("\trssi: "); + output.append(rssi); + output.append("\n"); + output.append("\tlqi: "); + output.append(lqi); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class NetworkCommissioningClusterWiFiInterfaceScanResult { +public Integer security; +public byte[] ssid; +public byte[] bssid; +public Integer channel; +public Integer wiFiBand; +public Integer rssi; + + public NetworkCommissioningClusterWiFiInterfaceScanResult( + Integer security + , byte[] ssid + , byte[] bssid + , Integer channel + , Integer wiFiBand + , Integer rssi + ) { + this.security = security; + this.ssid = ssid; + this.bssid = bssid; + this.channel = channel; + this.wiFiBand = wiFiBand; + this.rssi = rssi; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterWiFiInterfaceScanResult {\n"); + output.append("\tsecurity: "); + output.append(security); + output.append("\n"); + output.append("\tssid: "); + output.append(Arrays.toString(ssid)); + output.append("\n"); + output.append("\tbssid: "); + output.append(Arrays.toString(bssid)); + output.append("\n"); + output.append("\tchannel: "); + output.append(channel); + output.append("\n"); + output.append("\twiFiBand: "); + output.append(wiFiBand); + output.append("\n"); + output.append("\trssi: "); + output.append(rssi); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class OtaSoftwareUpdateRequestorClusterProviderLocation { +public Integer fabricIndex; +public Long providerNodeID; +public Integer endpoint; + + public OtaSoftwareUpdateRequestorClusterProviderLocation( + Integer fabricIndex + , Long providerNodeID + , Integer endpoint + ) { + this.fabricIndex = fabricIndex; + this.providerNodeID = providerNodeID; + this.endpoint = endpoint; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OtaSoftwareUpdateRequestorClusterProviderLocation {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tproviderNodeID: "); + output.append(providerNodeID); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class OperationalCredentialsClusterFabricDescriptor { +public Integer fabricIndex; +public byte[] rootPublicKey; +public Integer vendorId; +public Long fabricId; +public Long nodeId; +public String label; + + public OperationalCredentialsClusterFabricDescriptor( + Integer fabricIndex + , byte[] rootPublicKey + , Integer vendorId + , Long fabricId + , Long nodeId + , String label + ) { + this.fabricIndex = fabricIndex; + this.rootPublicKey = rootPublicKey; + this.vendorId = vendorId; + this.fabricId = fabricId; + this.nodeId = nodeId; + this.label = label; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OperationalCredentialsClusterFabricDescriptor {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\trootPublicKey: "); + output.append(Arrays.toString(rootPublicKey)); + output.append("\n"); + output.append("\tvendorId: "); + output.append(vendorId); + output.append("\n"); + output.append("\tfabricId: "); + output.append(fabricId); + output.append("\n"); + output.append("\tnodeId: "); + output.append(nodeId); + output.append("\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class OperationalCredentialsClusterNOCStruct { +public Integer fabricIndex; +public byte[] noc; +public @Nullable byte[] icac; + + public OperationalCredentialsClusterNOCStruct( + Integer fabricIndex + , byte[] noc + , @Nullable byte[] icac + ) { + this.fabricIndex = fabricIndex; + this.noc = noc; + this.icac = icac; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OperationalCredentialsClusterNOCStruct {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tnoc: "); + output.append(Arrays.toString(noc)); + output.append("\n"); + output.append("\ticac: "); + output.append(Arrays.toString(icac)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class PowerSourceClusterBatChargeFaultChangeType { +public ArrayList current; +public ArrayList previous; + + public PowerSourceClusterBatChargeFaultChangeType( + ArrayList current + , ArrayList previous + ) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatChargeFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class PowerSourceClusterBatFaultChangeType { +public ArrayList current; +public ArrayList previous; + + public PowerSourceClusterBatFaultChangeType( + ArrayList current + , ArrayList previous + ) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class PowerSourceClusterWiredFaultChangeType { +public ArrayList current; +public ArrayList previous; + + public PowerSourceClusterWiredFaultChangeType( + ArrayList current + , ArrayList previous + ) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterWiredFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ScenesClusterSceneExtensionFieldSet { +public Long clusterId; +public Integer length; +public Integer value; + + public ScenesClusterSceneExtensionFieldSet( + Long clusterId + , Integer length + , Integer value + ) { + this.clusterId = clusterId; + this.length = length; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ScenesClusterSceneExtensionFieldSet {\n"); + output.append("\tclusterId: "); + output.append(clusterId); + output.append("\n"); + output.append("\tlength: "); + output.append(length); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class SoftwareDiagnosticsClusterSoftwareFaultStruct { +public Long id; +public String name; +public byte[] faultRecording; + + public SoftwareDiagnosticsClusterSoftwareFaultStruct( + Long id + , String name + , byte[] faultRecording + ) { + this.id = id; + this.name = name; + this.faultRecording = faultRecording; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SoftwareDiagnosticsClusterSoftwareFaultStruct {\n"); + output.append("\tid: "); + output.append(id); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tfaultRecording: "); + output.append(Arrays.toString(faultRecording)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class SoftwareDiagnosticsClusterThreadMetrics { +public Long id; +public String name; +public Long stackFreeCurrent; +public Long stackFreeMinimum; +public Long stackSize; + + public SoftwareDiagnosticsClusterThreadMetrics( + Long id + , String name + , Long stackFreeCurrent + , Long stackFreeMinimum + , Long stackSize + ) { + this.id = id; + this.name = name; + this.stackFreeCurrent = stackFreeCurrent; + this.stackFreeMinimum = stackFreeMinimum; + this.stackSize = stackSize; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SoftwareDiagnosticsClusterThreadMetrics {\n"); + output.append("\tid: "); + output.append(id); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tstackFreeCurrent: "); + output.append(stackFreeCurrent); + output.append("\n"); + output.append("\tstackFreeMinimum: "); + output.append(stackFreeMinimum); + output.append("\n"); + output.append("\tstackSize: "); + output.append(stackSize); + output.append("\n"); + output.append("}\n"); + return output.toString(); } } + +public static class TargetNavigatorClusterTargetInfo { +public Integer identifier; +public String name; + + public TargetNavigatorClusterTargetInfo( + Integer identifier + , String name + ) { + this.identifier = identifier; + this.name = name; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TargetNavigatorClusterTargetInfo {\n"); + output.append("\tidentifier: "); + output.append(identifier); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterSimpleStruct { +public Integer a; +public Boolean b; +public Integer c; +public byte[] d; +public String e; +public Integer f; +public Float g; +public Double h; + + public TestClusterClusterSimpleStruct( + Integer a + , Boolean b + , Integer c + , byte[] d + , String e + , Integer f + , Float g + , Double h + ) { + this.a = a; + this.b = b; + this.c = c; + this.d = d; + this.e = e; + this.f = f; + this.g = g; + this.h = h; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterSimpleStruct {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("\td: "); + output.append(Arrays.toString(d)); + output.append("\n"); + output.append("\te: "); + output.append(e); + output.append("\n"); + output.append("\tf: "); + output.append(f); + output.append("\n"); + output.append("\tg: "); + output.append(g); + output.append("\n"); + output.append("\th: "); + output.append(h); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterNullablesAndOptionalsStruct { +public @Nullable Integer nullableInt; +public Optional optionalInt; +public @Nullable Optional nullableOptionalInt; +public @Nullable String nullableString; +public Optional optionalString; +public @Nullable Optional nullableOptionalString; +public @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct; +public Optional optionalStruct; +public @Nullable Optional nullableOptionalStruct; +public @Nullable ArrayList nullableList; +public Optional> optionalList; +public @Nullable Optional> nullableOptionalList; + + public TestClusterClusterNullablesAndOptionalsStruct( + @Nullable Integer nullableInt + , Optional optionalInt + , @Nullable Optional nullableOptionalInt + , @Nullable String nullableString + , Optional optionalString + , @Nullable Optional nullableOptionalString + , @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct + , Optional optionalStruct + , @Nullable Optional nullableOptionalStruct + , @Nullable ArrayList nullableList + , Optional> optionalList + , @Nullable Optional> nullableOptionalList + ) { + this.nullableInt = nullableInt; + this.optionalInt = optionalInt; + this.nullableOptionalInt = nullableOptionalInt; + this.nullableString = nullableString; + this.optionalString = optionalString; + this.nullableOptionalString = nullableOptionalString; + this.nullableStruct = nullableStruct; + this.optionalStruct = optionalStruct; + this.nullableOptionalStruct = nullableOptionalStruct; + this.nullableList = nullableList; + this.optionalList = optionalList; + this.nullableOptionalList = nullableOptionalList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNullablesAndOptionalsStruct {\n"); + output.append("\tnullableInt: "); + output.append(nullableInt); + output.append("\n"); + output.append("\toptionalInt: "); + output.append(optionalInt); + output.append("\n"); + output.append("\tnullableOptionalInt: "); + output.append(nullableOptionalInt); + output.append("\n"); + output.append("\tnullableString: "); + output.append(nullableString); + output.append("\n"); + output.append("\toptionalString: "); + output.append(optionalString); + output.append("\n"); + output.append("\tnullableOptionalString: "); + output.append(nullableOptionalString); + output.append("\n"); + output.append("\tnullableStruct: "); + output.append(nullableStruct); + output.append("\n"); + output.append("\toptionalStruct: "); + output.append(optionalStruct); + output.append("\n"); + output.append("\tnullableOptionalStruct: "); + output.append(nullableOptionalStruct); + output.append("\n"); + output.append("\tnullableList: "); + output.append(nullableList); + output.append("\n"); + output.append("\toptionalList: "); + output.append(optionalList); + output.append("\n"); + output.append("\tnullableOptionalList: "); + output.append(nullableOptionalList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterNestedStruct { +public Integer a; +public Boolean b; +public ChipStructs.TestClusterClusterSimpleStruct c; + + public TestClusterClusterNestedStruct( + Integer a + , Boolean b + , ChipStructs.TestClusterClusterSimpleStruct c + ) { + this.a = a; + this.b = b; + this.c = c; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNestedStruct {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterNestedStructList { +public Integer a; +public Boolean b; +public ChipStructs.TestClusterClusterSimpleStruct c; +public ArrayList d; +public ArrayList e; +public ArrayList f; +public ArrayList g; + + public TestClusterClusterNestedStructList( + Integer a + , Boolean b + , ChipStructs.TestClusterClusterSimpleStruct c + , ArrayList d + , ArrayList e + , ArrayList f + , ArrayList g + ) { + this.a = a; + this.b = b; + this.c = c; + this.d = d; + this.e = e; + this.f = f; + this.g = g; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNestedStructList {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("\td: "); + output.append(d); + output.append("\n"); + output.append("\te: "); + output.append(e); + output.append("\n"); + output.append("\tf: "); + output.append(f); + output.append("\n"); + output.append("\tg: "); + output.append(g); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterDoubleNestedStructList { +public ArrayList a; + + public TestClusterClusterDoubleNestedStructList( + ArrayList a + ) { + this.a = a; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterDoubleNestedStructList {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterTestFabricScoped { +public Integer fabricIndex; + + public TestClusterClusterTestFabricScoped( + Integer fabricIndex + ) { + this.fabricIndex = fabricIndex; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterTestFabricScoped {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class TestClusterClusterTestListStructOctet { +public Long fabricIndex; +public byte[] operationalCert; + + public TestClusterClusterTestListStructOctet( + Long fabricIndex + , byte[] operationalCert + ) { + this.fabricIndex = fabricIndex; + this.operationalCert = operationalCert; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterTestListStructOctet {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\toperationalCert: "); + output.append(Arrays.toString(operationalCert)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ThreadNetworkDiagnosticsClusterNeighborTable { +public Long extAddress; +public Long age; +public Integer rloc16; +public Long linkFrameCounter; +public Long mleFrameCounter; +public Integer lqi; +public Integer averageRssi; +public Integer lastRssi; +public Integer frameErrorRate; +public Integer messageErrorRate; +public Boolean rxOnWhenIdle; +public Boolean fullThreadDevice; +public Boolean fullNetworkData; +public Boolean isChild; + + public ThreadNetworkDiagnosticsClusterNeighborTable( + Long extAddress + , Long age + , Integer rloc16 + , Long linkFrameCounter + , Long mleFrameCounter + , Integer lqi + , Integer averageRssi + , Integer lastRssi + , Integer frameErrorRate + , Integer messageErrorRate + , Boolean rxOnWhenIdle + , Boolean fullThreadDevice + , Boolean fullNetworkData + , Boolean isChild + ) { + this.extAddress = extAddress; + this.age = age; + this.rloc16 = rloc16; + this.linkFrameCounter = linkFrameCounter; + this.mleFrameCounter = mleFrameCounter; + this.lqi = lqi; + this.averageRssi = averageRssi; + this.lastRssi = lastRssi; + this.frameErrorRate = frameErrorRate; + this.messageErrorRate = messageErrorRate; + this.rxOnWhenIdle = rxOnWhenIdle; + this.fullThreadDevice = fullThreadDevice; + this.fullNetworkData = fullNetworkData; + this.isChild = isChild; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterNeighborTable {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\tage: "); + output.append(age); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\tlinkFrameCounter: "); + output.append(linkFrameCounter); + output.append("\n"); + output.append("\tmleFrameCounter: "); + output.append(mleFrameCounter); + output.append("\n"); + output.append("\tlqi: "); + output.append(lqi); + output.append("\n"); + output.append("\taverageRssi: "); + output.append(averageRssi); + output.append("\n"); + output.append("\tlastRssi: "); + output.append(lastRssi); + output.append("\n"); + output.append("\tframeErrorRate: "); + output.append(frameErrorRate); + output.append("\n"); + output.append("\tmessageErrorRate: "); + output.append(messageErrorRate); + output.append("\n"); + output.append("\trxOnWhenIdle: "); + output.append(rxOnWhenIdle); + output.append("\n"); + output.append("\tfullThreadDevice: "); + output.append(fullThreadDevice); + output.append("\n"); + output.append("\tfullNetworkData: "); + output.append(fullNetworkData); + output.append("\n"); + output.append("\tisChild: "); + output.append(isChild); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ThreadNetworkDiagnosticsClusterOperationalDatasetComponents { +public Boolean activeTimestampPresent; +public Boolean pendingTimestampPresent; +public Boolean masterKeyPresent; +public Boolean networkNamePresent; +public Boolean extendedPanIdPresent; +public Boolean meshLocalPrefixPresent; +public Boolean delayPresent; +public Boolean panIdPresent; +public Boolean channelPresent; +public Boolean pskcPresent; +public Boolean securityPolicyPresent; +public Boolean channelMaskPresent; + + public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents( + Boolean activeTimestampPresent + , Boolean pendingTimestampPresent + , Boolean masterKeyPresent + , Boolean networkNamePresent + , Boolean extendedPanIdPresent + , Boolean meshLocalPrefixPresent + , Boolean delayPresent + , Boolean panIdPresent + , Boolean channelPresent + , Boolean pskcPresent + , Boolean securityPolicyPresent + , Boolean channelMaskPresent + ) { + this.activeTimestampPresent = activeTimestampPresent; + this.pendingTimestampPresent = pendingTimestampPresent; + this.masterKeyPresent = masterKeyPresent; + this.networkNamePresent = networkNamePresent; + this.extendedPanIdPresent = extendedPanIdPresent; + this.meshLocalPrefixPresent = meshLocalPrefixPresent; + this.delayPresent = delayPresent; + this.panIdPresent = panIdPresent; + this.channelPresent = channelPresent; + this.pskcPresent = pskcPresent; + this.securityPolicyPresent = securityPolicyPresent; + this.channelMaskPresent = channelMaskPresent; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterOperationalDatasetComponents {\n"); + output.append("\tactiveTimestampPresent: "); + output.append(activeTimestampPresent); + output.append("\n"); + output.append("\tpendingTimestampPresent: "); + output.append(pendingTimestampPresent); + output.append("\n"); + output.append("\tmasterKeyPresent: "); + output.append(masterKeyPresent); + output.append("\n"); + output.append("\tnetworkNamePresent: "); + output.append(networkNamePresent); + output.append("\n"); + output.append("\textendedPanIdPresent: "); + output.append(extendedPanIdPresent); + output.append("\n"); + output.append("\tmeshLocalPrefixPresent: "); + output.append(meshLocalPrefixPresent); + output.append("\n"); + output.append("\tdelayPresent: "); + output.append(delayPresent); + output.append("\n"); + output.append("\tpanIdPresent: "); + output.append(panIdPresent); + output.append("\n"); + output.append("\tchannelPresent: "); + output.append(channelPresent); + output.append("\n"); + output.append("\tpskcPresent: "); + output.append(pskcPresent); + output.append("\n"); + output.append("\tsecurityPolicyPresent: "); + output.append(securityPolicyPresent); + output.append("\n"); + output.append("\tchannelMaskPresent: "); + output.append(channelMaskPresent); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ThreadNetworkDiagnosticsClusterRouteTable { +public Long extAddress; +public Integer rloc16; +public Integer routerId; +public Integer nextHop; +public Integer pathCost; +public Integer LQIIn; +public Integer LQIOut; +public Integer age; +public Boolean allocated; +public Boolean linkEstablished; + + public ThreadNetworkDiagnosticsClusterRouteTable( + Long extAddress + , Integer rloc16 + , Integer routerId + , Integer nextHop + , Integer pathCost + , Integer LQIIn + , Integer LQIOut + , Integer age + , Boolean allocated + , Boolean linkEstablished + ) { + this.extAddress = extAddress; + this.rloc16 = rloc16; + this.routerId = routerId; + this.nextHop = nextHop; + this.pathCost = pathCost; + this.LQIIn = LQIIn; + this.LQIOut = LQIOut; + this.age = age; + this.allocated = allocated; + this.linkEstablished = linkEstablished; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterRouteTable {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\trouterId: "); + output.append(routerId); + output.append("\n"); + output.append("\tnextHop: "); + output.append(nextHop); + output.append("\n"); + output.append("\tpathCost: "); + output.append(pathCost); + output.append("\n"); + output.append("\tLQIIn: "); + output.append(LQIIn); + output.append("\n"); + output.append("\tLQIOut: "); + output.append(LQIOut); + output.append("\n"); + output.append("\tage: "); + output.append(age); + output.append("\n"); + output.append("\tallocated: "); + output.append(allocated); + output.append("\n"); + output.append("\tlinkEstablished: "); + output.append(linkEstablished); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class ThreadNetworkDiagnosticsClusterSecurityPolicy { +public Integer rotationTime; +public Integer flags; + + public ThreadNetworkDiagnosticsClusterSecurityPolicy( + Integer rotationTime + , Integer flags + ) { + this.rotationTime = rotationTime; + this.flags = flags; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterSecurityPolicy {\n"); + output.append("\trotationTime: "); + output.append(rotationTime); + output.append("\n"); + output.append("\tflags: "); + output.append(flags); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +public static class UserLabelClusterLabelStruct { +public String label; +public String value; + + public UserLabelClusterLabelStruct( + String label + , String value + ) { + this.label = label; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("UserLabelClusterLabelStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } +} + +} \ No newline at end of file diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index 8bead24d836255..206c331e05b755 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -20,24 +20,26 @@ package chip.devicecontroller; import androidx.annotation.Nullable; -import chip.clusterinfo.ClusterCommandCallback; -import chip.clusterinfo.ClusterInfo; -import chip.clusterinfo.CommandParameterInfo; -import chip.clusterinfo.CommandResponseInfo; -import chip.clusterinfo.DelegatedClusterCallback; -import chip.clusterinfo.InteractionInfo; -import chip.devicecontroller.ChipClusters.DefaultClusterCallback; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Optional; +import androidx.annotation.Nullable; +import chip.clusterinfo.ClusterInfo; +import chip.clusterinfo.InteractionInfo; +import chip.clusterinfo.CommandParameterInfo; +import chip.clusterinfo.DelegatedClusterCallback; +import chip.clusterinfo.ClusterCommandCallback; +import chip.clusterinfo.CommandResponseInfo; +import chip.devicecontroller.ChipClusters.DefaultClusterCallback; +import chip.devicecontroller.ClusterReadMapping; +import chip.devicecontroller.ClusterWriteMapping; public class ClusterInfoMapping { - public static class DelegatedCharStringAttributeCallback - implements ChipClusters.CharStringAttributeCallback, DelegatedClusterCallback { + public static class DelegatedCharStringAttributeCallback implements ChipClusters.CharStringAttributeCallback, DelegatedClusterCallback { /** Indicates a successful read for a CHAR_STRING attribute. */ private ClusterCommandCallback callback; @@ -60,8 +62,7 @@ public void onError(Exception error) { } } - public static class DelegatedOctetStringAttributeCallback - implements ChipClusters.OctetStringAttributeCallback, DelegatedClusterCallback { + public static class DelegatedOctetStringAttributeCallback implements ChipClusters.OctetStringAttributeCallback, DelegatedClusterCallback { /** Indicates a successful read for an OCTET_STRING attribute. */ private ClusterCommandCallback callback; @@ -84,8 +85,7 @@ public void onError(Exception error) { } } - public static class DelegatedIntegerAttributeCallback - implements ChipClusters.IntegerAttributeCallback, DelegatedClusterCallback { + public static class DelegatedIntegerAttributeCallback implements ChipClusters.IntegerAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -107,8 +107,7 @@ public void onError(Exception error) { } } - public static class DelegatedLongAttributeCallback - implements ChipClusters.LongAttributeCallback, DelegatedClusterCallback { + public static class DelegatedLongAttributeCallback implements ChipClusters.LongAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -130,8 +129,7 @@ public void onError(Exception error) { } } - public static class DelegatedBooleanAttributeCallback - implements ChipClusters.BooleanAttributeCallback, DelegatedClusterCallback { + public static class DelegatedBooleanAttributeCallback implements ChipClusters.BooleanAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -153,8 +151,7 @@ public void onError(Exception error) { } } - public static class DelegatedFloatAttributeCallback - implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { + public static class DelegatedFloatAttributeCallback implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -176,8 +173,7 @@ public void onError(Exception error) { } } - public static class DelegatedDoubleAttributeCallback - implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { + public static class DelegatedDoubleAttributeCallback implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -199,8 +195,7 @@ public void onError(Exception error) { } } - public static class DelegatedDefaultClusterCallback - implements DefaultClusterCallback, DelegatedClusterCallback { + public static class DelegatedDefaultClusterCallback implements DefaultClusterCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -208,8 +203,7 @@ public void setCallbackDelegate(ClusterCommandCallback callback) { this.callback = callback; } - // Parameters and list-adds here should be generated - refer to the template code that creates - // each callback interface. + // Parameters and list-adds here should be generated - refer to the template code that creates each callback interface. @Override public void onSuccess() { Map responseValues = new LinkedHashMap<>(); @@ -222,8880 +216,7545 @@ public void onError(Exception e) { } } - public static class DelegatedAccessControlClusterAclAttributeCallback - implements ChipClusters.AccessControlCluster.AclAttributeCallback, 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 DelegatedAccessControlClusterExtensionAttributeCallback - implements ChipClusters.AccessControlCluster.ExtensionAttributeCallback, - 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 DelegatedAccessControlClusterAttributeListAttributeCallback - implements ChipClusters.AccessControlCluster.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 DelegatedGetSetupPINResponseCallback - implements ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(String setupPIN) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("setupPIN", "String"); - responseValues.put(setupPINResponseValue, setupPIN); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedAccountLoginClusterAttributeListAttributeCallback - implements ChipClusters.AccountLoginCluster.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 DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback - implements ChipClusters.AdministratorCommissioningCluster.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 DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback - implements ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback, - 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 DelegatedApplicationBasicClusterAttributeListAttributeCallback - implements ChipClusters.ApplicationBasicCluster.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 DelegatedLauncherResponseCallback - implements ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback - implements ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback, - 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 DelegatedApplicationLauncherClusterAttributeListAttributeCallback - implements ChipClusters.ApplicationLauncherCluster.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 DelegatedAudioOutputClusterAudioOutputListAttributeCallback - implements ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback, - 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 DelegatedAudioOutputClusterAttributeListAttributeCallback - implements ChipClusters.AudioOutputCluster.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 DelegatedBarrierControlClusterAttributeListAttributeCallback - implements ChipClusters.BarrierControlCluster.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); - } + public static class DelegatedAccessControlClusterAclAttributeCallback implements ChipClusters.AccessControlCluster.AclAttributeCallback, 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 DelegatedAccessControlClusterExtensionAttributeCallback implements ChipClusters.AccessControlCluster.ExtensionAttributeCallback, 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 DelegatedAccessControlClusterAttributeListAttributeCallback implements ChipClusters.AccessControlCluster.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 DelegatedGetSetupPINResponseCallback implements ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(String setupPIN) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("setupPIN", "String"); + responseValues.put(setupPINResponseValue, setupPIN); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedAccountLoginClusterAttributeListAttributeCallback implements ChipClusters.AccountLoginCluster.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 DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback implements ChipClusters.AdministratorCommissioningCluster.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 DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback implements ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback, 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 DelegatedApplicationBasicClusterAttributeListAttributeCallback implements ChipClusters.ApplicationBasicCluster.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 DelegatedLauncherResponseCallback implements ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback implements ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback, 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 DelegatedApplicationLauncherClusterAttributeListAttributeCallback implements ChipClusters.ApplicationLauncherCluster.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 DelegatedAudioOutputClusterAudioOutputListAttributeCallback implements ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback, 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 DelegatedAudioOutputClusterAttributeListAttributeCallback implements ChipClusters.AudioOutputCluster.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 DelegatedBarrierControlClusterAttributeListAttributeCallback implements ChipClusters.BarrierControlCluster.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 DelegatedBasicClusterAttributeListAttributeCallback implements ChipClusters.BasicCluster.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 DelegatedBinaryInputBasicClusterAttributeListAttributeCallback implements ChipClusters.BinaryInputBasicCluster.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 DelegatedBindingClusterAttributeListAttributeCallback implements ChipClusters.BindingCluster.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 DelegatedBooleanStateClusterAttributeListAttributeCallback implements ChipClusters.BooleanStateCluster.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 DelegatedBridgedActionsClusterActionListAttributeCallback implements ChipClusters.BridgedActionsCluster.ActionListAttributeCallback, 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 DelegatedBridgedActionsClusterEndpointListAttributeCallback implements ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback, 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 DelegatedBridgedActionsClusterAttributeListAttributeCallback implements ChipClusters.BridgedActionsCluster.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 DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback implements ChipClusters.BridgedDeviceBasicCluster.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 DelegatedChangeChannelResponseCallback implements ChipClusters.ChannelCluster.ChangeChannelResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType) { + Map responseValues = new LinkedHashMap<>(); + // channelMatch: Struct ChannelInfo + // Conversion from this type to Java is not properly implemented yet + CommandResponseInfo errorTypeResponseValue = new CommandResponseInfo("errorType", "Integer"); + responseValues.put(errorTypeResponseValue, errorType); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedChannelClusterChannelListAttributeCallback implements ChipClusters.ChannelCluster.ChannelListAttributeCallback, 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 DelegatedChannelClusterAttributeListAttributeCallback implements ChipClusters.ChannelCluster.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 DelegatedColorControlClusterAttributeListAttributeCallback implements ChipClusters.ColorControlCluster.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 DelegatedLaunchResponseCallback implements ChipClusters.ContentLauncherCluster.LaunchResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback implements ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback, 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 DelegatedContentLauncherClusterAttributeListAttributeCallback implements ChipClusters.ContentLauncherCluster.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 DelegatedDescriptorClusterDeviceListAttributeCallback implements ChipClusters.DescriptorCluster.DeviceListAttributeCallback, 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 DelegatedDescriptorClusterServerListAttributeCallback implements ChipClusters.DescriptorCluster.ServerListAttributeCallback, 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 DelegatedDescriptorClusterClientListAttributeCallback implements ChipClusters.DescriptorCluster.ClientListAttributeCallback, 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 DelegatedDescriptorClusterPartsListAttributeCallback implements ChipClusters.DescriptorCluster.PartsListAttributeCallback, 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 DelegatedDescriptorClusterAttributeListAttributeCallback implements ChipClusters.DescriptorCluster.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 DelegatedRetrieveLogsResponseCallback implements ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo contentResponseValue = new CommandResponseInfo("content", "byte[]"); + responseValues.put(contentResponseValue, content); + CommandResponseInfo timeStampResponseValue = new CommandResponseInfo("timeStamp", "Long"); + responseValues.put(timeStampResponseValue, timeStamp); + CommandResponseInfo timeSinceBootResponseValue = new CommandResponseInfo("timeSinceBoot", "Long"); + responseValues.put(timeSinceBootResponseValue, timeSinceBoot); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedDiagnosticLogsClusterAttributeListAttributeCallback implements ChipClusters.DiagnosticLogsCluster.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 DelegatedGetCredentialStatusResponseCallback implements ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo credentialExistsResponseValue = new CommandResponseInfo("credentialExists", "Boolean"); + responseValues.put(credentialExistsResponseValue, credentialExists); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo nextCredentialIndexResponseValue = new CommandResponseInfo("nextCredentialIndex", "Integer"); + responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetUserResponseCallback implements ChipClusters.DoorLockCluster.GetUserResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo userNameResponseValue = new CommandResponseInfo("userName", "String"); + responseValues.put(userNameResponseValue, userName); + CommandResponseInfo userUniqueIdResponseValue = new CommandResponseInfo("userUniqueId", "Long"); + responseValues.put(userUniqueIdResponseValue, userUniqueId); + CommandResponseInfo userStatusResponseValue = new CommandResponseInfo("userStatus", "Integer"); + responseValues.put(userStatusResponseValue, userStatus); + CommandResponseInfo userTypeResponseValue = new CommandResponseInfo("userType", "Integer"); + responseValues.put(userTypeResponseValue, userType); + CommandResponseInfo credentialRuleResponseValue = new CommandResponseInfo("credentialRule", "Integer"); + responseValues.put(credentialRuleResponseValue, credentialRule); + // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + CommandResponseInfo creatorFabricIndexResponseValue = new CommandResponseInfo("creatorFabricIndex", "Integer"); + responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); + CommandResponseInfo lastModifiedFabricIndexResponseValue = new CommandResponseInfo("lastModifiedFabricIndex", "Integer"); + responseValues.put(lastModifiedFabricIndexResponseValue, lastModifiedFabricIndex); + CommandResponseInfo nextUserIndexResponseValue = new CommandResponseInfo("nextUserIndex", "Integer"); + responseValues.put(nextUserIndexResponseValue, nextUserIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetWeekDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo weekDayIndexResponseValue = new CommandResponseInfo("weekDayIndex", "Integer"); + responseValues.put(weekDayIndexResponseValue, weekDayIndex); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo daysMaskResponseValue = new CommandResponseInfo("daysMask", "Optional"); + responseValues.put(daysMaskResponseValue, daysMask); + CommandResponseInfo startHourResponseValue = new CommandResponseInfo("startHour", "Optional"); + responseValues.put(startHourResponseValue, startHour); + CommandResponseInfo startMinuteResponseValue = new CommandResponseInfo("startMinute", "Optional"); + responseValues.put(startMinuteResponseValue, startMinute); + CommandResponseInfo endHourResponseValue = new CommandResponseInfo("endHour", "Optional"); + responseValues.put(endHourResponseValue, endHour); + CommandResponseInfo endMinuteResponseValue = new CommandResponseInfo("endMinute", "Optional"); + responseValues.put(endMinuteResponseValue, endMinute); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetYearDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo yearDayIndexResponseValue = new CommandResponseInfo("yearDayIndex", "Integer"); + responseValues.put(yearDayIndexResponseValue, yearDayIndex); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo localStartTimeResponseValue = new CommandResponseInfo("localStartTime", "Optional"); + responseValues.put(localStartTimeResponseValue, localStartTime); + CommandResponseInfo localEndTimeResponseValue = new CommandResponseInfo("localEndTime", "Optional"); + responseValues.put(localEndTimeResponseValue, localEndTime); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSetCredentialResponseCallback implements ChipClusters.DoorLockCluster.SetCredentialResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo nextCredentialIndexResponseValue = new CommandResponseInfo("nextCredentialIndex", "Integer"); + responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedDoorLockClusterAttributeListAttributeCallback implements ChipClusters.DoorLockCluster.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 DelegatedElectricalMeasurementClusterAttributeListAttributeCallback implements ChipClusters.ElectricalMeasurementCluster.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 DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.EthernetNetworkDiagnosticsCluster.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 DelegatedFixedLabelClusterLabelListAttributeCallback implements ChipClusters.FixedLabelCluster.LabelListAttributeCallback, 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 DelegatedFixedLabelClusterAttributeListAttributeCallback implements ChipClusters.FixedLabelCluster.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 DelegatedFlowMeasurementClusterAttributeListAttributeCallback implements ChipClusters.FlowMeasurementCluster.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 DelegatedArmFailSafeResponseCallback implements ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedCommissioningCompleteResponseCallback implements ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSetRegulatoryConfigResponseCallback implements ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback implements ChipClusters.GeneralCommissioningCluster.BasicCommissioningInfoListAttributeCallback, 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 DelegatedGeneralCommissioningClusterAttributeListAttributeCallback implements ChipClusters.GeneralCommissioningCluster.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 DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.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 DelegatedKeySetReadAllIndicesResponseCallback implements ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ArrayList groupKeySetIDs) { + Map responseValues = new LinkedHashMap<>(); + // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedKeySetReadResponseCallback implements ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { + Map responseValues = new LinkedHashMap<>(); + // groupKeySet: Struct GroupKeySet + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback implements ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback, 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 DelegatedGroupKeyManagementClusterGroupTableAttributeCallback implements ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback, 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 DelegatedGroupKeyManagementClusterAttributeListAttributeCallback implements ChipClusters.GroupKeyManagementCluster.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 DelegatedAddGroupResponseCallback implements ChipClusters.GroupsCluster.AddGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetGroupMembershipResponseCallback implements ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer capacity, ArrayList groupList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); + responseValues.put(capacityResponseValue, capacity); + // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveGroupResponseCallback implements ChipClusters.GroupsCluster.RemoveGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedViewGroupResponseCallback implements ChipClusters.GroupsCluster.ViewGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, String groupName) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo groupNameResponseValue = new CommandResponseInfo("groupName", "String"); + responseValues.put(groupNameResponseValue, groupName); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedGroupsClusterAttributeListAttributeCallback implements ChipClusters.GroupsCluster.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 DelegatedIdentifyQueryResponseCallback implements ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer timeout) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo timeoutResponseValue = new CommandResponseInfo("timeout", "Integer"); + responseValues.put(timeoutResponseValue, timeout); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedIdentifyClusterAttributeListAttributeCallback implements ChipClusters.IdentifyCluster.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 DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback implements ChipClusters.IlluminanceMeasurementCluster.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 DelegatedSendKeyResponseCallback implements ChipClusters.KeypadInputCluster.SendKeyResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedKeypadInputClusterAttributeListAttributeCallback implements ChipClusters.KeypadInputCluster.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 DelegatedLevelControlClusterAttributeListAttributeCallback implements ChipClusters.LevelControlCluster.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 DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback implements ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback, 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 DelegatedLowPowerClusterAttributeListAttributeCallback implements ChipClusters.LowPowerCluster.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 DelegatedMediaInputClusterMediaInputListAttributeCallback implements ChipClusters.MediaInputCluster.MediaInputListAttributeCallback, 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 DelegatedMediaInputClusterAttributeListAttributeCallback implements ChipClusters.MediaInputCluster.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 DelegatedPlaybackResponseCallback implements ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedMediaPlaybackClusterAttributeListAttributeCallback implements ChipClusters.MediaPlaybackCluster.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 DelegatedModeSelectClusterSupportedModesAttributeCallback implements ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback, 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 DelegatedModeSelectClusterAttributeListAttributeCallback implements ChipClusters.ModeSelectCluster.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 DelegatedConnectNetworkResponseCallback implements ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText, Long ErrorValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + CommandResponseInfo ErrorValueResponseValue = new CommandResponseInfo("ErrorValue", "Long"); + responseValues.put(ErrorValueResponseValue, ErrorValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNetworkConfigResponseCallback implements ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedScanNetworksResponseCallback implements ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText, Optional> WiFiScanResults, Optional> ThreadScanResults) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + // WiFiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + // ThreadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedNetworkCommissioningClusterNetworksAttributeCallback implements ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback, 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 DelegatedApplyUpdateResponseCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer action, Long delayedActionTime) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo actionResponseValue = new CommandResponseInfo("action", "Integer"); + responseValues.put(actionResponseValue, action); + CommandResponseInfo delayedActionTimeResponseValue = new CommandResponseInfo("delayedActionTime", "Long"); + responseValues.put(delayedActionTimeResponseValue, delayedActionTime); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedQueryImageResponseCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo delayedActionTimeResponseValue = new CommandResponseInfo("delayedActionTime", "Optional"); + responseValues.put(delayedActionTimeResponseValue, delayedActionTime); + CommandResponseInfo imageURIResponseValue = new CommandResponseInfo("imageURI", "Optional"); + responseValues.put(imageURIResponseValue, imageURI); + CommandResponseInfo softwareVersionResponseValue = new CommandResponseInfo("softwareVersion", "Optional"); + responseValues.put(softwareVersionResponseValue, softwareVersion); + CommandResponseInfo softwareVersionStringResponseValue = new CommandResponseInfo("softwareVersionString", "Optional"); + responseValues.put(softwareVersionStringResponseValue, softwareVersionString); + CommandResponseInfo updateTokenResponseValue = new CommandResponseInfo("updateToken", "Optional"); + responseValues.put(updateTokenResponseValue, updateToken); + CommandResponseInfo userConsentNeededResponseValue = new CommandResponseInfo("userConsentNeeded", "Optional"); + responseValues.put(userConsentNeededResponseValue, userConsentNeeded); + CommandResponseInfo metadataForRequestorResponseValue = new CommandResponseInfo("metadataForRequestor", "Optional"); + responseValues.put(metadataForRequestorResponseValue, metadataForRequestor); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.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 DelegatedOtaSoftwareUpdateRequestorClusterDefaultOtaProvidersAttributeCallback implements ChipClusters.OtaSoftwareUpdateRequestorCluster.DefaultOtaProvidersAttributeCallback, 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 DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback implements ChipClusters.OtaSoftwareUpdateRequestorCluster.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 DelegatedOccupancySensingClusterAttributeListAttributeCallback implements ChipClusters.OccupancySensingCluster.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 DelegatedOnOffClusterAttributeListAttributeCallback implements ChipClusters.OnOffCluster.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 DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback implements ChipClusters.OnOffSwitchConfigurationCluster.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 DelegatedAttestationResponseCallback implements ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] AttestationElements, byte[] Signature) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo AttestationElementsResponseValue = new CommandResponseInfo("AttestationElements", "byte[]"); + responseValues.put(AttestationElementsResponseValue, AttestationElements); + CommandResponseInfo SignatureResponseValue = new CommandResponseInfo("Signature", "byte[]"); + responseValues.put(SignatureResponseValue, Signature); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedCertificateChainResponseCallback implements ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] Certificate) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo CertificateResponseValue = new CommandResponseInfo("Certificate", "byte[]"); + responseValues.put(CertificateResponseValue, Certificate); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNOCResponseCallback implements ChipClusters.OperationalCredentialsCluster.NOCResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer StatusCode, Integer FabricIndex, String DebugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo StatusCodeResponseValue = new CommandResponseInfo("StatusCode", "Integer"); + responseValues.put(StatusCodeResponseValue, StatusCode); + CommandResponseInfo FabricIndexResponseValue = new CommandResponseInfo("FabricIndex", "Integer"); + responseValues.put(FabricIndexResponseValue, FabricIndex); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedOpCSRResponseCallback implements ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] NOCSRElements, byte[] AttestationSignature) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NOCSRElementsResponseValue = new CommandResponseInfo("NOCSRElements", "byte[]"); + responseValues.put(NOCSRElementsResponseValue, NOCSRElements); + CommandResponseInfo AttestationSignatureResponseValue = new CommandResponseInfo("AttestationSignature", "byte[]"); + responseValues.put(AttestationSignatureResponseValue, AttestationSignature); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedOperationalCredentialsClusterNOCsAttributeCallback implements ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback, 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 DelegatedOperationalCredentialsClusterFabricsListAttributeCallback implements ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback, 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 DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback implements ChipClusters.OperationalCredentialsCluster.TrustedRootCertificatesAttributeCallback, 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 DelegatedOperationalCredentialsClusterAttributeListAttributeCallback implements ChipClusters.OperationalCredentialsCluster.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 DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback implements ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback, 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 DelegatedPowerSourceClusterAttributeListAttributeCallback implements ChipClusters.PowerSourceCluster.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 DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback implements ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback, 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 DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback implements ChipClusters.PowerSourceConfigurationCluster.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 DelegatedPressureMeasurementClusterAttributeListAttributeCallback implements ChipClusters.PressureMeasurementCluster.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 DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback implements ChipClusters.PumpConfigurationAndControlCluster.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 DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback implements ChipClusters.RelativeHumidityMeasurementCluster.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 DelegatedAddSceneResponseCallback implements ChipClusters.ScenesCluster.AddSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetSceneMembershipResponseCallback implements ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); + responseValues.put(capacityResponseValue, capacity); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneCountResponseValue = new CommandResponseInfo("sceneCount", "Integer"); + responseValues.put(sceneCountResponseValue, sceneCount); + // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveAllScenesResponseCallback implements ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveSceneResponseCallback implements ChipClusters.ScenesCluster.RemoveSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedStoreSceneResponseCallback implements ChipClusters.ScenesCluster.StoreSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedViewSceneResponseCallback implements ChipClusters.ScenesCluster.ViewSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + CommandResponseInfo transitionTimeResponseValue = new CommandResponseInfo("transitionTime", "Integer"); + responseValues.put(transitionTimeResponseValue, transitionTime); + CommandResponseInfo sceneNameResponseValue = new CommandResponseInfo("sceneName", "String"); + responseValues.put(sceneNameResponseValue, sceneName); + // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedScenesClusterAttributeListAttributeCallback implements ChipClusters.ScenesCluster.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 DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback implements ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback, 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 DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.SoftwareDiagnosticsCluster.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 DelegatedSwitchClusterAttributeListAttributeCallback implements ChipClusters.SwitchCluster.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 DelegatedNavigateTargetResponseCallback implements ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + + public static class DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback implements ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback, 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 DelegatedTargetNavigatorClusterAttributeListAttributeCallback implements ChipClusters.TargetNavigatorCluster.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 DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback implements ChipClusters.TemperatureMeasurementCluster.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 DelegatedBooleanResponseCallback implements ChipClusters.TestClusterCluster.BooleanResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Boolean value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Boolean"); + responseValues.put(valueResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSimpleStructResponseCallback implements ChipClusters.TestClusterCluster.SimpleStructResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1) { + Map responseValues = new LinkedHashMap<>(); + // arg1: Struct SimpleStruct + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestAddArgumentsResponseCallback implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer returnValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo returnValueResponseValue = new CommandResponseInfo("returnValue", "Integer"); + responseValues.put(returnValueResponseValue, returnValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestEmitTestEventResponseCallback implements ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Long value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Long"); + responseValues.put(valueResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestEnumsResponseCallback implements ChipClusters.TestClusterCluster.TestEnumsResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer arg1, Integer arg2) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo arg1ResponseValue = new CommandResponseInfo("arg1", "Integer"); + responseValues.put(arg1ResponseValue, arg1); + CommandResponseInfo arg2ResponseValue = new CommandResponseInfo("arg2", "Integer"); + responseValues.put(arg2ResponseValue, arg2); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestListInt8UReverseResponseCallback implements ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ArrayList arg1) { + Map responseValues = new LinkedHashMap<>(); + // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestNullableOptionalResponseCallback implements ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo wasPresentResponseValue = new CommandResponseInfo("wasPresent", "Boolean"); + responseValues.put(wasPresentResponseValue, wasPresent); + CommandResponseInfo wasNullResponseValue = new CommandResponseInfo("wasNull", "Optional"); + responseValues.put(wasNullResponseValue, wasNull); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Optional"); + responseValues.put(valueResponseValue, value); + CommandResponseInfo originalValueResponseValue = new CommandResponseInfo("originalValue", "Optional"); + responseValues.put(originalValueResponseValue, originalValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestSpecificResponseCallback implements ChipClusters.TestClusterCluster.TestSpecificResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer returnValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo returnValueResponseValue = new CommandResponseInfo("returnValue", "Integer"); + responseValues.put(returnValueResponseValue, returnValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedTestClusterClusterListInt8uAttributeCallback implements ChipClusters.TestClusterCluster.ListInt8uAttributeCallback, 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 DelegatedTestClusterClusterListOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback, 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 DelegatedTestClusterClusterListStructOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback, 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 DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback implements ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback, 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 DelegatedTestClusterClusterListLongOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback, 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 DelegatedTestClusterClusterAttributeListAttributeCallback implements ChipClusters.TestClusterCluster.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 DelegatedGetRelayStatusLogResponseCallback implements ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo timeOfDayResponseValue = new CommandResponseInfo("timeOfDay", "Integer"); + responseValues.put(timeOfDayResponseValue, timeOfDay); + CommandResponseInfo relayStatusResponseValue = new CommandResponseInfo("relayStatus", "Integer"); + responseValues.put(relayStatusResponseValue, relayStatus); + CommandResponseInfo localTemperatureResponseValue = new CommandResponseInfo("localTemperature", "Integer"); + responseValues.put(localTemperatureResponseValue, localTemperature); + CommandResponseInfo humidityInPercentageResponseValue = new CommandResponseInfo("humidityInPercentage", "Integer"); + responseValues.put(humidityInPercentageResponseValue, humidityInPercentage); + CommandResponseInfo setpointResponseValue = new CommandResponseInfo("setpoint", "Integer"); + responseValues.put(setpointResponseValue, setpoint); + CommandResponseInfo unreadEntriesResponseValue = new CommandResponseInfo("unreadEntries", "Integer"); + responseValues.put(unreadEntriesResponseValue, unreadEntries); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetWeeklyScheduleResponseCallback implements ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo numberOfTransitionsForSequenceResponseValue = new CommandResponseInfo("numberOfTransitionsForSequence", "Integer"); + responseValues.put(numberOfTransitionsForSequenceResponseValue, numberOfTransitionsForSequence); + CommandResponseInfo dayOfWeekForSequenceResponseValue = new CommandResponseInfo("dayOfWeekForSequence", "Integer"); + responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); + CommandResponseInfo modeForSequenceResponseValue = new CommandResponseInfo("modeForSequence", "Integer"); + responseValues.put(modeForSequenceResponseValue, modeForSequence); + // payload: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + + public static class DelegatedThermostatClusterAttributeListAttributeCallback implements ChipClusters.ThermostatCluster.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 DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback implements ChipClusters.ThermostatUserInterfaceConfigurationCluster.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 DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.OperationalDatasetComponentsAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.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 DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback implements ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback, 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 DelegatedUserLabelClusterLabelListAttributeCallback implements ChipClusters.UserLabelCluster.LabelListAttributeCallback, 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 DelegatedWakeOnLanClusterAttributeListAttributeCallback implements ChipClusters.WakeOnLanCluster.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 DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.WiFiNetworkDiagnosticsCluster.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 DelegatedWindowCoveringClusterAttributeListAttributeCallback implements ChipClusters.WindowCoveringCluster.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 Map getClusterMap() { + Map clusterMap = initializeClusterMap(); + Map> commandMap = getCommandMap(); + combineCommand(clusterMap, commandMap); + Map> readAttributeMap = new ClusterReadMapping().getReadAttributeMap(); + combineCommand(clusterMap, readAttributeMap); + Map> writeAttributeMap = new ClusterWriteMapping().getWriteAttributeMap(); + combineCommand(clusterMap, writeAttributeMap); + return clusterMap; + } - @Override - public void onError(Exception ex) { - callback.onFailure(ex); - } + public Map initializeClusterMap() { + Map clusterMap = new HashMap<>(); + ClusterInfo accessControlClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AccessControlCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("accessControl", accessControlClusterInfo); + ClusterInfo accountLoginClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("accountLogin", accountLoginClusterInfo); + ClusterInfo administratorCommissioningClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); + ClusterInfo applicationBasicClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("applicationBasic", applicationBasicClusterInfo); + ClusterInfo applicationLauncherClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); + ClusterInfo audioOutputClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("audioOutput", audioOutputClusterInfo); + ClusterInfo barrierControlClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("barrierControl", barrierControlClusterInfo); + ClusterInfo basicClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("basic", basicClusterInfo); + ClusterInfo binaryInputBasicClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); + ClusterInfo bindingClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("binding", bindingClusterInfo); + ClusterInfo booleanStateClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("booleanState", booleanStateClusterInfo); + ClusterInfo bridgedActionsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("bridgedActions", bridgedActionsClusterInfo); + ClusterInfo bridgedDeviceBasicClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); + ClusterInfo channelClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ChannelCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("channel", channelClusterInfo); + ClusterInfo colorControlClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("colorControl", colorControlClusterInfo); + ClusterInfo contentLauncherClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("contentLauncher", contentLauncherClusterInfo); + ClusterInfo descriptorClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("descriptor", descriptorClusterInfo); + ClusterInfo diagnosticLogsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); + ClusterInfo doorLockClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("doorLock", doorLockClusterInfo); + ClusterInfo electricalMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); + ClusterInfo ethernetNetworkDiagnosticsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); + ClusterInfo fixedLabelClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("fixedLabel", fixedLabelClusterInfo); + ClusterInfo flowMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); + ClusterInfo generalCommissioningClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); + ClusterInfo generalDiagnosticsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); + ClusterInfo groupKeyManagementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); + ClusterInfo groupsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("groups", groupsClusterInfo); + ClusterInfo identifyClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("identify", identifyClusterInfo); + ClusterInfo illuminanceMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); + ClusterInfo keypadInputClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("keypadInput", keypadInputClusterInfo); + ClusterInfo levelControlClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("levelControl", levelControlClusterInfo); + ClusterInfo localizationConfigurationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LocalizationConfigurationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("localizationConfiguration", localizationConfigurationClusterInfo); + ClusterInfo lowPowerClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("lowPower", lowPowerClusterInfo); + ClusterInfo mediaInputClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("mediaInput", mediaInputClusterInfo); + ClusterInfo mediaPlaybackClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); + ClusterInfo modeSelectClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("modeSelect", modeSelectClusterInfo); + ClusterInfo networkCommissioningClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); + ClusterInfo otaSoftwareUpdateProviderClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); + ClusterInfo otaSoftwareUpdateRequestorClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); + ClusterInfo occupancySensingClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("occupancySensing", occupancySensingClusterInfo); + ClusterInfo onOffClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("onOff", onOffClusterInfo); + ClusterInfo onOffSwitchConfigurationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); + ClusterInfo operationalCredentialsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); + ClusterInfo powerSourceClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("powerSource", powerSourceClusterInfo); + ClusterInfo powerSourceConfigurationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PowerSourceConfigurationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInfo); + ClusterInfo pressureMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); + ClusterInfo pumpConfigurationAndControlClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); + ClusterInfo relativeHumidityMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); + ClusterInfo scenesClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("scenes", scenesClusterInfo); + ClusterInfo softwareDiagnosticsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); + ClusterInfo switchClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("switch", switchClusterInfo); + ClusterInfo targetNavigatorClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("targetNavigator", targetNavigatorClusterInfo); + ClusterInfo temperatureMeasurementClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); + ClusterInfo testClusterClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("testCluster", testClusterClusterInfo); + ClusterInfo thermostatClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("thermostat", thermostatClusterInfo); + ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); + ClusterInfo threadNetworkDiagnosticsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); + ClusterInfo timeFormatLocalizationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TimeFormatLocalizationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("timeFormatLocalization", timeFormatLocalizationClusterInfo); + ClusterInfo unitLocalizationClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.UnitLocalizationCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("unitLocalization", unitLocalizationClusterInfo); + ClusterInfo userLabelClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.UserLabelCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("userLabel", userLabelClusterInfo); + ClusterInfo wakeOnLanClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); + ClusterInfo wiFiNetworkDiagnosticsClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); + ClusterInfo windowCoveringClusterInfo = new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("windowCovering", windowCoveringClusterInfo); + return clusterMap; + } + + public void combineCommand(Map destination, Map> source) { + destination.get("accessControl").combineCommands(source.get("accessControl")); + destination.get("accountLogin").combineCommands(source.get("accountLogin")); + destination.get("administratorCommissioning").combineCommands(source.get("administratorCommissioning")); + destination.get("applicationBasic").combineCommands(source.get("applicationBasic")); + destination.get("applicationLauncher").combineCommands(source.get("applicationLauncher")); + destination.get("audioOutput").combineCommands(source.get("audioOutput")); + destination.get("barrierControl").combineCommands(source.get("barrierControl")); + destination.get("basic").combineCommands(source.get("basic")); + destination.get("binaryInputBasic").combineCommands(source.get("binaryInputBasic")); + destination.get("binding").combineCommands(source.get("binding")); + destination.get("booleanState").combineCommands(source.get("booleanState")); + destination.get("bridgedActions").combineCommands(source.get("bridgedActions")); + destination.get("bridgedDeviceBasic").combineCommands(source.get("bridgedDeviceBasic")); + destination.get("channel").combineCommands(source.get("channel")); + destination.get("colorControl").combineCommands(source.get("colorControl")); + destination.get("contentLauncher").combineCommands(source.get("contentLauncher")); + destination.get("descriptor").combineCommands(source.get("descriptor")); + destination.get("diagnosticLogs").combineCommands(source.get("diagnosticLogs")); + destination.get("doorLock").combineCommands(source.get("doorLock")); + destination.get("electricalMeasurement").combineCommands(source.get("electricalMeasurement")); + destination.get("ethernetNetworkDiagnostics").combineCommands(source.get("ethernetNetworkDiagnostics")); + destination.get("fixedLabel").combineCommands(source.get("fixedLabel")); + destination.get("flowMeasurement").combineCommands(source.get("flowMeasurement")); + destination.get("generalCommissioning").combineCommands(source.get("generalCommissioning")); + destination.get("generalDiagnostics").combineCommands(source.get("generalDiagnostics")); + destination.get("groupKeyManagement").combineCommands(source.get("groupKeyManagement")); + destination.get("groups").combineCommands(source.get("groups")); + destination.get("identify").combineCommands(source.get("identify")); + destination.get("illuminanceMeasurement").combineCommands(source.get("illuminanceMeasurement")); + destination.get("keypadInput").combineCommands(source.get("keypadInput")); + destination.get("levelControl").combineCommands(source.get("levelControl")); + destination.get("localizationConfiguration").combineCommands(source.get("localizationConfiguration")); + destination.get("lowPower").combineCommands(source.get("lowPower")); + destination.get("mediaInput").combineCommands(source.get("mediaInput")); + destination.get("mediaPlayback").combineCommands(source.get("mediaPlayback")); + destination.get("modeSelect").combineCommands(source.get("modeSelect")); + destination.get("networkCommissioning").combineCommands(source.get("networkCommissioning")); + destination.get("otaSoftwareUpdateProvider").combineCommands(source.get("otaSoftwareUpdateProvider")); + destination.get("otaSoftwareUpdateRequestor").combineCommands(source.get("otaSoftwareUpdateRequestor")); + destination.get("occupancySensing").combineCommands(source.get("occupancySensing")); + destination.get("onOff").combineCommands(source.get("onOff")); + destination.get("onOffSwitchConfiguration").combineCommands(source.get("onOffSwitchConfiguration")); + destination.get("operationalCredentials").combineCommands(source.get("operationalCredentials")); + destination.get("powerSource").combineCommands(source.get("powerSource")); + destination.get("powerSourceConfiguration").combineCommands(source.get("powerSourceConfiguration")); + destination.get("pressureMeasurement").combineCommands(source.get("pressureMeasurement")); + destination.get("pumpConfigurationAndControl").combineCommands(source.get("pumpConfigurationAndControl")); + destination.get("relativeHumidityMeasurement").combineCommands(source.get("relativeHumidityMeasurement")); + destination.get("scenes").combineCommands(source.get("scenes")); + destination.get("softwareDiagnostics").combineCommands(source.get("softwareDiagnostics")); + destination.get("switch").combineCommands(source.get("switch")); + destination.get("targetNavigator").combineCommands(source.get("targetNavigator")); + destination.get("temperatureMeasurement").combineCommands(source.get("temperatureMeasurement")); + destination.get("testCluster").combineCommands(source.get("testCluster")); + destination.get("thermostat").combineCommands(source.get("thermostat")); + destination.get("thermostatUserInterfaceConfiguration").combineCommands(source.get("thermostatUserInterfaceConfiguration")); + destination.get("threadNetworkDiagnostics").combineCommands(source.get("threadNetworkDiagnostics")); + destination.get("timeFormatLocalization").combineCommands(source.get("timeFormatLocalization")); + destination.get("unitLocalization").combineCommands(source.get("unitLocalization")); + destination.get("userLabel").combineCommands(source.get("userLabel")); + destination.get("wakeOnLan").combineCommands(source.get("wakeOnLan")); + destination.get("wiFiNetworkDiagnostics").combineCommands(source.get("wiFiNetworkDiagnostics")); + destination.get("windowCovering").combineCommands(source.get("windowCovering")); + } + + @SuppressWarnings("unchecked") + public Map> getCommandMap() { + Map> commandMap = new HashMap<>(); + Map accessControlClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("accessControl", accessControlClusterInteractionInfoMap); + Map accountLoginClusterInteractionInfoMap = new LinkedHashMap<>(); + Map accountLogingetSetupPINRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); + accountLogingetSetupPINRequestCommandParams.put("tempAccountIdentifier",accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); + + InteractionInfo accountLogingetSetupPINRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .getSetupPINRequest((ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback) callback + , (String) + commandArguments.get("tempAccountIdentifier") + , 10000 + ); + }, + () -> new DelegatedGetSetupPINResponseCallback(), + accountLogingetSetupPINRequestCommandParams + ); + accountLoginClusterInteractionInfoMap.put("getSetupPINRequest", accountLogingetSetupPINRequestInteractionInfo); + Map accountLoginloginRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); + accountLoginloginRequestCommandParams.put("tempAccountIdentifier",accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); + + CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = new CommandParameterInfo("setupPIN", String.class); + accountLoginloginRequestCommandParams.put("setupPIN",accountLoginloginRequestsetupPINCommandParameterInfo); + + InteractionInfo accountLoginloginRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .loginRequest((DefaultClusterCallback) callback + , (String) + commandArguments.get("tempAccountIdentifier") + , (String) + commandArguments.get("setupPIN") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + accountLoginloginRequestCommandParams + ); + accountLoginClusterInteractionInfoMap.put("loginRequest", accountLoginloginRequestInteractionInfo); + Map accountLoginlogoutRequestCommandParams = new LinkedHashMap(); + InteractionInfo accountLoginlogoutRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .logoutRequest((DefaultClusterCallback) callback + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + accountLoginlogoutRequestCommandParams + ); + accountLoginClusterInteractionInfoMap.put("logoutRequest", accountLoginlogoutRequestInteractionInfo); + commandMap.put("accountLogin", accountLoginClusterInteractionInfoMap); + Map administratorCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); + Map administratorCommissioningopenBasicCommissioningWindowCommandParams = new LinkedHashMap(); + CommandParameterInfo administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); + administratorCommissioningopenBasicCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); + + InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .openBasicCommissioningWindow((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("commissioningTimeout") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningopenBasicCommissioningWindowCommandParams + ); + administratorCommissioningClusterInteractionInfoMap.put("openBasicCommissioningWindow", administratorCommissioningopenBasicCommissioningWindowInteractionInfo); + Map administratorCommissioningopenCommissioningWindowCommandParams = new LinkedHashMap(); + CommandParameterInfo administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = new CommandParameterInfo("PAKEVerifier", byte[].class); + administratorCommissioningopenCommissioningWindowCommandParams.put("PAKEVerifier",administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = new CommandParameterInfo("discriminator", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put("discriminator",administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = new CommandParameterInfo("iterations", Long.class); + administratorCommissioningopenCommissioningWindowCommandParams.put("iterations",administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = new CommandParameterInfo("salt", byte[].class); + administratorCommissioningopenCommissioningWindowCommandParams.put("salt",administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = new CommandParameterInfo("passcodeID", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put("passcodeID",administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); + + InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .openCommissioningWindow((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("commissioningTimeout") + , (byte[]) + commandArguments.get("PAKEVerifier") + , (Integer) + commandArguments.get("discriminator") + , (Long) + commandArguments.get("iterations") + , (byte[]) + commandArguments.get("salt") + , (Integer) + commandArguments.get("passcodeID") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningopenCommissioningWindowCommandParams + ); + administratorCommissioningClusterInteractionInfoMap.put("openCommissioningWindow", administratorCommissioningopenCommissioningWindowInteractionInfo); + Map administratorCommissioningrevokeCommissioningCommandParams = new LinkedHashMap(); + InteractionInfo administratorCommissioningrevokeCommissioningInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .revokeCommissioning((DefaultClusterCallback) callback + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningrevokeCommissioningCommandParams + ); + administratorCommissioningClusterInteractionInfoMap.put("revokeCommissioning", administratorCommissioningrevokeCommissioningInteractionInfo); + commandMap.put("administratorCommissioning", administratorCommissioningClusterInteractionInfoMap); + Map applicationBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("applicationBasic", applicationBasicClusterInteractionInfoMap); + Map applicationLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); + Map applicationLauncherhideAppRequestCommandParams = new LinkedHashMap(); + InteractionInfo applicationLauncherhideAppRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .hideAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback + , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application") + + ); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherhideAppRequestCommandParams + ); + applicationLauncherClusterInteractionInfoMap.put("hideAppRequest", applicationLauncherhideAppRequestInteractionInfo); + Map applicationLauncherlaunchAppRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); + applicationLauncherlaunchAppRequestCommandParams.put("data",applicationLauncherlaunchAppRequestdataCommandParameterInfo); + + InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .launchAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback + , (String) + commandArguments.get("data") + , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application") + + ); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherlaunchAppRequestCommandParams + ); + applicationLauncherClusterInteractionInfoMap.put("launchAppRequest", applicationLauncherlaunchAppRequestInteractionInfo); + Map applicationLauncherstopAppRequestCommandParams = new LinkedHashMap(); + InteractionInfo applicationLauncherstopAppRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .stopAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback + , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application") + + ); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherstopAppRequestCommandParams + ); + applicationLauncherClusterInteractionInfoMap.put("stopAppRequest", applicationLauncherstopAppRequestInteractionInfo); + commandMap.put("applicationLauncher", applicationLauncherClusterInteractionInfoMap); + Map audioOutputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map audioOutputrenameOutputRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); + audioOutputrenameOutputRequestCommandParams.put("index",audioOutputrenameOutputRequestindexCommandParameterInfo); + + CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); + audioOutputrenameOutputRequestCommandParams.put("name",audioOutputrenameOutputRequestnameCommandParameterInfo); + + InteractionInfo audioOutputrenameOutputRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .renameOutputRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("index") + , (String) + commandArguments.get("name") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + audioOutputrenameOutputRequestCommandParams + ); + audioOutputClusterInteractionInfoMap.put("renameOutputRequest", audioOutputrenameOutputRequestInteractionInfo); + Map audioOutputselectOutputRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); + audioOutputselectOutputRequestCommandParams.put("index",audioOutputselectOutputRequestindexCommandParameterInfo); + + InteractionInfo audioOutputselectOutputRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .selectOutputRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("index") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + audioOutputselectOutputRequestCommandParams + ); + audioOutputClusterInteractionInfoMap.put("selectOutputRequest", audioOutputselectOutputRequestInteractionInfo); + commandMap.put("audioOutput", audioOutputClusterInteractionInfoMap); + Map barrierControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map barrierControlbarrierControlGoToPercentCommandParams = new LinkedHashMap(); + CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = new CommandParameterInfo("percentOpen", Integer.class); + barrierControlbarrierControlGoToPercentCommandParams.put("percentOpen",barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); + + InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .barrierControlGoToPercent((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("percentOpen") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + barrierControlbarrierControlGoToPercentCommandParams + ); + barrierControlClusterInteractionInfoMap.put("barrierControlGoToPercent", barrierControlbarrierControlGoToPercentInteractionInfo); + Map barrierControlbarrierControlStopCommandParams = new LinkedHashMap(); + InteractionInfo barrierControlbarrierControlStopInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .barrierControlStop((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + barrierControlbarrierControlStopCommandParams + ); + barrierControlClusterInteractionInfoMap.put("barrierControlStop", barrierControlbarrierControlStopInteractionInfo); + commandMap.put("barrierControl", barrierControlClusterInteractionInfoMap); + Map basicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("basic", basicClusterInteractionInfoMap); + Map binaryInputBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("binaryInputBasic", binaryInputBasicClusterInteractionInfoMap); + Map bindingClusterInteractionInfoMap = new LinkedHashMap<>(); + Map bindingbindCommandParams = new LinkedHashMap(); + CommandParameterInfo bindingbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); + bindingbindCommandParams.put("nodeId",bindingbindnodeIdCommandParameterInfo); + + CommandParameterInfo bindingbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + bindingbindCommandParams.put("groupId",bindingbindgroupIdCommandParameterInfo); + + CommandParameterInfo bindingbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); + bindingbindCommandParams.put("endpointId",bindingbindendpointIdCommandParameterInfo); + + CommandParameterInfo bindingbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); + bindingbindCommandParams.put("clusterId",bindingbindclusterIdCommandParameterInfo); + + InteractionInfo bindingbindInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .bind((DefaultClusterCallback) callback + , (Long) + commandArguments.get("nodeId") + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("endpointId") + , (Long) + commandArguments.get("clusterId") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bindingbindCommandParams + ); + bindingClusterInteractionInfoMap.put("bind", bindingbindInteractionInfo); + Map bindingunbindCommandParams = new LinkedHashMap(); + CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); + bindingunbindCommandParams.put("nodeId",bindingunbindnodeIdCommandParameterInfo); + + CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + bindingunbindCommandParams.put("groupId",bindingunbindgroupIdCommandParameterInfo); + + CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); + bindingunbindCommandParams.put("endpointId",bindingunbindendpointIdCommandParameterInfo); + + CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); + bindingunbindCommandParams.put("clusterId",bindingunbindclusterIdCommandParameterInfo); + + InteractionInfo bindingunbindInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .unbind((DefaultClusterCallback) callback + , (Long) + commandArguments.get("nodeId") + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("endpointId") + , (Long) + commandArguments.get("clusterId") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bindingunbindCommandParams + ); + bindingClusterInteractionInfoMap.put("unbind", bindingunbindInteractionInfo); + commandMap.put("binding", bindingClusterInteractionInfoMap); + Map booleanStateClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("booleanState", booleanStateClusterInteractionInfoMap); + Map bridgedActionsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map bridgedActionsdisableActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsdisableActionCommandParams.put("actionID",bridgedActionsdisableActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsdisableActionCommandParams.put("invokeID",bridgedActionsdisableActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsdisableActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .disableAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsdisableActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("disableAction", bridgedActionsdisableActionInteractionInfo); + Map bridgedActionsdisableActionWithDurationCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsdisableActionWithDurationCommandParams.put("actionID",bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsdisableActionWithDurationCommandParams.put("invokeID",bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); + bridgedActionsdisableActionWithDurationCommandParams.put("duration",bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .disableActionWithDuration((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + , (Long) + commandArguments.get("duration") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsdisableActionWithDurationCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("disableActionWithDuration", bridgedActionsdisableActionWithDurationInteractionInfo); + Map bridgedActionsenableActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsenableActionCommandParams.put("actionID",bridgedActionsenableActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsenableActionCommandParams.put("invokeID",bridgedActionsenableActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsenableActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .enableAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsenableActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("enableAction", bridgedActionsenableActionInteractionInfo); + Map bridgedActionsenableActionWithDurationCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsenableActionWithDurationCommandParams.put("actionID",bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsenableActionWithDurationCommandParams.put("invokeID",bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); + bridgedActionsenableActionWithDurationCommandParams.put("duration",bridgedActionsenableActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .enableActionWithDuration((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + , (Long) + commandArguments.get("duration") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsenableActionWithDurationCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("enableActionWithDuration", bridgedActionsenableActionWithDurationInteractionInfo); + Map bridgedActionsinstantActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsinstantActionCommandParams.put("actionID",bridgedActionsinstantActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsinstantActionCommandParams.put("invokeID",bridgedActionsinstantActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsinstantActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .instantAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsinstantActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("instantAction", bridgedActionsinstantActionInteractionInfo); + Map bridgedActionsinstantActionWithTransitionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsinstantActionWithTransitionCommandParams.put("actionID",bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsinstantActionWithTransitionCommandParams.put("invokeID",bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + bridgedActionsinstantActionWithTransitionCommandParams.put("transitionTime",bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); + + InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .instantActionWithTransition((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + , (Integer) + commandArguments.get("transitionTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsinstantActionWithTransitionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("instantActionWithTransition", bridgedActionsinstantActionWithTransitionInteractionInfo); + Map bridgedActionspauseActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionspauseActionCommandParams.put("actionID",bridgedActionspauseActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionspauseActionCommandParams.put("invokeID",bridgedActionspauseActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionspauseActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .pauseAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionspauseActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("pauseAction", bridgedActionspauseActionInteractionInfo); + Map bridgedActionspauseActionWithDurationCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionspauseActionWithDurationCommandParams.put("actionID",bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionspauseActionWithDurationCommandParams.put("invokeID",bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); + bridgedActionspauseActionWithDurationCommandParams.put("duration",bridgedActionspauseActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .pauseActionWithDuration((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + , (Long) + commandArguments.get("duration") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionspauseActionWithDurationCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("pauseActionWithDuration", bridgedActionspauseActionWithDurationInteractionInfo); + Map bridgedActionsresumeActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsresumeActionCommandParams.put("actionID",bridgedActionsresumeActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsresumeActionCommandParams.put("invokeID",bridgedActionsresumeActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsresumeActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .resumeAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsresumeActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("resumeAction", bridgedActionsresumeActionInteractionInfo); + Map bridgedActionsstartActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstartActionCommandParams.put("actionID",bridgedActionsstartActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstartActionCommandParams.put("invokeID",bridgedActionsstartActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsstartActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .startAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstartActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("startAction", bridgedActionsstartActionInteractionInfo); + Map bridgedActionsstartActionWithDurationCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstartActionWithDurationCommandParams.put("actionID",bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstartActionWithDurationCommandParams.put("invokeID",bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); + bridgedActionsstartActionWithDurationCommandParams.put("duration",bridgedActionsstartActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .startActionWithDuration((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + , (Long) + commandArguments.get("duration") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstartActionWithDurationCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("startActionWithDuration", bridgedActionsstartActionWithDurationInteractionInfo); + Map bridgedActionsstopActionCommandParams = new LinkedHashMap(); + CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstopActionCommandParams.put("actionID",bridgedActionsstopActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstopActionCommandParams.put("invokeID",bridgedActionsstopActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsstopActionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .stopAction((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("actionID") + , (Optional) + commandArguments.get("invokeID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstopActionCommandParams + ); + bridgedActionsClusterInteractionInfoMap.put("stopAction", bridgedActionsstopActionInteractionInfo); + commandMap.put("bridgedActions", bridgedActionsClusterInteractionInfoMap); + Map bridgedDeviceBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInteractionInfoMap); + Map channelClusterInteractionInfoMap = new LinkedHashMap<>(); + Map channelchangeChannelByNumberRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = new CommandParameterInfo("majorNumber", Integer.class); + channelchangeChannelByNumberRequestCommandParams.put("majorNumber",channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); + + CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = new CommandParameterInfo("minorNumber", Integer.class); + channelchangeChannelByNumberRequestCommandParams.put("minorNumber",channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); + + InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .changeChannelByNumberRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("majorNumber") + , (Integer) + commandArguments.get("minorNumber") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + channelchangeChannelByNumberRequestCommandParams + ); + channelClusterInteractionInfoMap.put("changeChannelByNumberRequest", channelchangeChannelByNumberRequestInteractionInfo); + Map channelchangeChannelRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = new CommandParameterInfo("match", String.class); + channelchangeChannelRequestCommandParams.put("match",channelchangeChannelRequestmatchCommandParameterInfo); + + InteractionInfo channelchangeChannelRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .changeChannelRequest((ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback + , (String) + commandArguments.get("match") + + ); + }, + () -> new DelegatedChangeChannelResponseCallback(), + channelchangeChannelRequestCommandParams + ); + channelClusterInteractionInfoMap.put("changeChannelRequest", channelchangeChannelRequestInteractionInfo); + Map channelskipChannelRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = new CommandParameterInfo("count", Integer.class); + channelskipChannelRequestCommandParams.put("count",channelskipChannelRequestcountCommandParameterInfo); + + InteractionInfo channelskipChannelRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .skipChannelRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("count") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + channelskipChannelRequestCommandParams + ); + channelClusterInteractionInfoMap.put("skipChannelRequest", channelskipChannelRequestInteractionInfo); + commandMap.put("channel", channelClusterInteractionInfoMap); + Map colorControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map colorControlcolorLoopSetCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = new CommandParameterInfo("updateFlags", Integer.class); + colorControlcolorLoopSetCommandParams.put("updateFlags",colorControlcolorLoopSetupdateFlagsCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = new CommandParameterInfo("action", Integer.class); + colorControlcolorLoopSetCommandParams.put("action",colorControlcolorLoopSetactionCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); + colorControlcolorLoopSetCommandParams.put("direction",colorControlcolorLoopSetdirectionCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = new CommandParameterInfo("time", Integer.class); + colorControlcolorLoopSetCommandParams.put("time",colorControlcolorLoopSettimeCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = new CommandParameterInfo("startHue", Integer.class); + colorControlcolorLoopSetCommandParams.put("startHue",colorControlcolorLoopSetstartHueCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlcolorLoopSetCommandParams.put("optionsMask",colorControlcolorLoopSetoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlcolorLoopSetCommandParams.put("optionsOverride",colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlcolorLoopSetInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .colorLoopSet((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("updateFlags") + , (Integer) + commandArguments.get("action") + , (Integer) + commandArguments.get("direction") + , (Integer) + commandArguments.get("time") + , (Integer) + commandArguments.get("startHue") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlcolorLoopSetCommandParams + ); + colorControlClusterInteractionInfoMap.put("colorLoopSet", colorControlcolorLoopSetInteractionInfo); + Map colorControlenhancedMoveHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + colorControlenhancedMoveHueCommandParams.put("moveMode",colorControlenhancedMoveHuemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + colorControlenhancedMoveHueCommandParams.put("rate",colorControlenhancedMoveHuerateCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveHueCommandParams.put("optionsMask",colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveHueCommandParams.put("optionsOverride",colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("enhancedMoveHue", colorControlenhancedMoveHueInteractionInfo); + Map colorControlenhancedMoveToHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); + colorControlenhancedMoveToHueCommandParams.put("enhancedHue",colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); + colorControlenhancedMoveToHueCommandParams.put("direction",colorControlenhancedMoveToHuedirectionCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedMoveToHueCommandParams.put("transitionTime",colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveToHueCommandParams.put("optionsMask",colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveToHueCommandParams.put("optionsOverride",colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveToHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveToHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("enhancedHue") + , (Integer) + commandArguments.get("direction") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveToHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("enhancedMoveToHue", colorControlenhancedMoveToHueInteractionInfo); + Map colorControlenhancedMoveToHueAndSaturationCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put("enhancedHue",colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put("saturation",colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put("transitionTime",colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsMask",colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveToHueAndSaturation((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("enhancedHue") + , (Integer) + commandArguments.get("saturation") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveToHueAndSaturationCommandParams + ); + colorControlClusterInteractionInfoMap.put("enhancedMoveToHueAndSaturation", colorControlenhancedMoveToHueAndSaturationInteractionInfo); + Map colorControlenhancedStepHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + colorControlenhancedStepHueCommandParams.put("stepMode",colorControlenhancedStepHuestepModeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + colorControlenhancedStepHueCommandParams.put("stepSize",colorControlenhancedStepHuestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedStepHueCommandParams.put("transitionTime",colorControlenhancedStepHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedStepHueCommandParams.put("optionsMask",colorControlenhancedStepHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedStepHueCommandParams.put("optionsOverride",colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedStepHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedStepHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedStepHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("enhancedStepHue", colorControlenhancedStepHueInteractionInfo); + Map colorControlmoveColorCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = new CommandParameterInfo("rateX", Integer.class); + colorControlmoveColorCommandParams.put("rateX",colorControlmoveColorrateXCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = new CommandParameterInfo("rateY", Integer.class); + colorControlmoveColorCommandParams.put("rateY",colorControlmoveColorrateYCommandParameterInfo); + + CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveColorCommandParams.put("optionsMask",colorControlmoveColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveColorCommandParams.put("optionsOverride",colorControlmoveColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveColorInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveColor((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("rateX") + , (Integer) + commandArguments.get("rateY") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveColorCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveColor", colorControlmoveColorInteractionInfo); + Map colorControlmoveColorTemperatureCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("moveMode",colorControlmoveColorTemperaturemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("rate",colorControlmoveColorTemperaturerateCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("optionsMask",colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveColorTemperatureCommandParams.put("optionsOverride",colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveColorTemperatureInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveColorTemperature((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + , (Integer) + commandArguments.get("colorTemperatureMinimum") + , (Integer) + commandArguments.get("colorTemperatureMaximum") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveColorTemperatureCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveColorTemperature", colorControlmoveColorTemperatureInteractionInfo); + Map colorControlmoveHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveHueCommandParams.put("moveMode",colorControlmoveHuemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + colorControlmoveHueCommandParams.put("rate",colorControlmoveHuerateCommandParameterInfo); + + CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveHueCommandParams.put("optionsMask",colorControlmoveHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveHueCommandParams.put("optionsOverride",colorControlmoveHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveHue", colorControlmoveHueInteractionInfo); + Map colorControlmoveSaturationCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveSaturationCommandParams.put("moveMode",colorControlmoveSaturationmoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + colorControlmoveSaturationCommandParams.put("rate",colorControlmoveSaturationrateCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveSaturationCommandParams.put("optionsMask",colorControlmoveSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveSaturationCommandParams.put("optionsOverride",colorControlmoveSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveSaturationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveSaturation((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveSaturationCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveSaturation", colorControlmoveSaturationInteractionInfo); + Map colorControlmoveToColorCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = new CommandParameterInfo("colorX", Integer.class); + colorControlmoveToColorCommandParams.put("colorX",colorControlmoveToColorcolorXCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = new CommandParameterInfo("colorY", Integer.class); + colorControlmoveToColorCommandParams.put("colorY",colorControlmoveToColorcolorYCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToColorCommandParams.put("transitionTime",colorControlmoveToColortransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToColorCommandParams.put("optionsMask",colorControlmoveToColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToColorCommandParams.put("optionsOverride",colorControlmoveToColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToColorInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToColor((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("colorX") + , (Integer) + commandArguments.get("colorY") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToColorCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveToColor", colorControlmoveToColorInteractionInfo); + Map colorControlmoveToColorTemperatureCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = new CommandParameterInfo("colorTemperature", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put("colorTemperature",colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put("transitionTime",colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put("optionsMask",colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put("optionsOverride",colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToColorTemperature((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("colorTemperature") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToColorTemperatureCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveToColorTemperature", colorControlmoveToColorTemperatureInteractionInfo); + Map colorControlmoveToHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); + colorControlmoveToHueCommandParams.put("hue",colorControlmoveToHuehueCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); + colorControlmoveToHueCommandParams.put("direction",colorControlmoveToHuedirectionCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToHueCommandParams.put("transitionTime",colorControlmoveToHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToHueCommandParams.put("optionsMask",colorControlmoveToHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToHueCommandParams.put("optionsOverride",colorControlmoveToHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("hue") + , (Integer) + commandArguments.get("direction") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveToHue", colorControlmoveToHueInteractionInfo); + Map colorControlmoveToHueAndSaturationCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put("hue",colorControlmoveToHueAndSaturationhueCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put("saturation",colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put("transitionTime",colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put("optionsMask",colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToHueAndSaturation((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("hue") + , (Integer) + commandArguments.get("saturation") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToHueAndSaturationCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveToHueAndSaturation", colorControlmoveToHueAndSaturationInteractionInfo); + Map colorControlmoveToSaturationCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); + colorControlmoveToSaturationCommandParams.put("saturation",colorControlmoveToSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToSaturationCommandParams.put("transitionTime",colorControlmoveToSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToSaturationCommandParams.put("optionsMask",colorControlmoveToSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToSaturationCommandParams.put("optionsOverride",colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToSaturationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToSaturation((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("saturation") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToSaturationCommandParams + ); + colorControlClusterInteractionInfoMap.put("moveToSaturation", colorControlmoveToSaturationInteractionInfo); + Map colorControlstepColorCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = new CommandParameterInfo("stepX", Integer.class); + colorControlstepColorCommandParams.put("stepX",colorControlstepColorstepXCommandParameterInfo); + + CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = new CommandParameterInfo("stepY", Integer.class); + colorControlstepColorCommandParams.put("stepY",colorControlstepColorstepYCommandParameterInfo); + + CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepColorCommandParams.put("transitionTime",colorControlstepColortransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepColorCommandParams.put("optionsMask",colorControlstepColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepColorCommandParams.put("optionsOverride",colorControlstepColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepColorInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepColor((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepX") + , (Integer) + commandArguments.get("stepY") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepColorCommandParams + ); + colorControlClusterInteractionInfoMap.put("stepColor", colorControlstepColorInteractionInfo); + Map colorControlstepColorTemperatureCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + colorControlstepColorTemperatureCommandParams.put("stepMode",colorControlstepColorTemperaturestepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + colorControlstepColorTemperatureCommandParams.put("stepSize",colorControlstepColorTemperaturestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepColorTemperatureCommandParams.put("transitionTime",colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); + colorControlstepColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); + colorControlstepColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepColorTemperatureCommandParams.put("optionsMask",colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepColorTemperatureCommandParams.put("optionsOverride",colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepColorTemperatureInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepColorTemperature((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("colorTemperatureMinimum") + , (Integer) + commandArguments.get("colorTemperatureMaximum") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepColorTemperatureCommandParams + ); + colorControlClusterInteractionInfoMap.put("stepColorTemperature", colorControlstepColorTemperatureInteractionInfo); + Map colorControlstepHueCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + colorControlstepHueCommandParams.put("stepMode",colorControlstepHuestepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + colorControlstepHueCommandParams.put("stepSize",colorControlstepHuestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepHueCommandParams.put("transitionTime",colorControlstepHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepHueCommandParams.put("optionsMask",colorControlstepHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepHueCommandParams.put("optionsOverride",colorControlstepHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepHueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepHue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepHueCommandParams + ); + colorControlClusterInteractionInfoMap.put("stepHue", colorControlstepHueInteractionInfo); + Map colorControlstepSaturationCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + colorControlstepSaturationCommandParams.put("stepMode",colorControlstepSaturationstepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + colorControlstepSaturationCommandParams.put("stepSize",colorControlstepSaturationstepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepSaturationCommandParams.put("transitionTime",colorControlstepSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepSaturationCommandParams.put("optionsMask",colorControlstepSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepSaturationCommandParams.put("optionsOverride",colorControlstepSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepSaturationInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepSaturation((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepSaturationCommandParams + ); + colorControlClusterInteractionInfoMap.put("stepSaturation", colorControlstepSaturationInteractionInfo); + Map colorControlstopMoveStepCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); + colorControlstopMoveStepCommandParams.put("optionsMask",colorControlstopMoveStepoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstopMoveStepCommandParams.put("optionsOverride",colorControlstopMoveStepoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstopMoveStepInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stopMoveStep((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("optionsMask") + , (Integer) + commandArguments.get("optionsOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstopMoveStepCommandParams + ); + colorControlClusterInteractionInfoMap.put("stopMoveStep", colorControlstopMoveStepInteractionInfo); + commandMap.put("colorControl", colorControlClusterInteractionInfoMap); + Map contentLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); + Map contentLauncherlaunchContentRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = new CommandParameterInfo("autoPlay", Boolean.class); + contentLauncherlaunchContentRequestCommandParams.put("autoPlay",contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); + + CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); + contentLauncherlaunchContentRequestCommandParams.put("data",contentLauncherlaunchContentRequestdataCommandParameterInfo); + + InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .launchContentRequest((ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback + , (Boolean) + commandArguments.get("autoPlay") + , (String) + commandArguments.get("data") + , (ArrayList) + commandArguments.get("search") + + ); + }, + () -> new DelegatedLaunchResponseCallback(), + contentLauncherlaunchContentRequestCommandParams + ); + contentLauncherClusterInteractionInfoMap.put("launchContentRequest", contentLauncherlaunchContentRequestInteractionInfo); + Map contentLauncherlaunchURLRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = new CommandParameterInfo("contentURL", String.class); + contentLauncherlaunchURLRequestCommandParams.put("contentURL",contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); + + CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = new CommandParameterInfo("displayString", String.class); + contentLauncherlaunchURLRequestCommandParams.put("displayString",contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); + + InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .launchURLRequest((ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback + , (String) + commandArguments.get("contentURL") + , (String) + commandArguments.get("displayString") + , (ChipStructs.ContentLauncherClusterBrandingInformation) + commandArguments.get("brandingInformation") + + ); + }, + () -> new DelegatedLaunchResponseCallback(), + contentLauncherlaunchURLRequestCommandParams + ); + contentLauncherClusterInteractionInfoMap.put("launchURLRequest", contentLauncherlaunchURLRequestInteractionInfo); + commandMap.put("contentLauncher", contentLauncherClusterInteractionInfoMap); + Map descriptorClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("descriptor", descriptorClusterInteractionInfoMap); + Map diagnosticLogsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map diagnosticLogsretrieveLogsRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = new CommandParameterInfo("intent", Integer.class); + diagnosticLogsretrieveLogsRequestCommandParams.put("intent",diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); + + CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = new CommandParameterInfo("requestedProtocol", Integer.class); + diagnosticLogsretrieveLogsRequestCommandParams.put("requestedProtocol",diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); + + CommandParameterInfo diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = new CommandParameterInfo("transferFileDesignator", byte[].class); + diagnosticLogsretrieveLogsRequestCommandParams.put("transferFileDesignator",diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); + + InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .retrieveLogsRequest((ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback) callback + , (Integer) + commandArguments.get("intent") + , (Integer) + commandArguments.get("requestedProtocol") + , (byte[]) + commandArguments.get("transferFileDesignator") + + ); + }, + () -> new DelegatedRetrieveLogsResponseCallback(), + diagnosticLogsretrieveLogsRequestCommandParams + ); + diagnosticLogsClusterInteractionInfoMap.put("retrieveLogsRequest", diagnosticLogsretrieveLogsRequestInteractionInfo); + commandMap.put("diagnosticLogs", diagnosticLogsClusterInteractionInfoMap); + Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); + Map doorLockclearCredentialCommandParams = new LinkedHashMap(); + InteractionInfo doorLockclearCredentialInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearCredential((DefaultClusterCallback) callback + , (ChipStructs.DoorLockClusterDlCredential) + commandArguments.get("credential") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearCredentialCommandParams + ); + doorLockClusterInteractionInfoMap.put("clearCredential", doorLockclearCredentialInteractionInfo); + Map doorLockclearUserCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockclearUserCommandParams.put("userIndex",doorLockclearUseruserIndexCommandParameterInfo); + + InteractionInfo doorLockclearUserInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearUser((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("userIndex") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearUserCommandParams + ); + doorLockClusterInteractionInfoMap.put("clearUser", doorLockclearUserInteractionInfo); + Map doorLockclearWeekDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); + doorLockclearWeekDayScheduleCommandParams.put("weekDayIndex",doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockclearWeekDayScheduleCommandParams.put("userIndex",doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearWeekDaySchedule((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("weekDayIndex") + , (Integer) + commandArguments.get("userIndex") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearWeekDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("clearWeekDaySchedule", doorLockclearWeekDayScheduleInteractionInfo); + Map doorLockclearYearDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); + doorLockclearYearDayScheduleCommandParams.put("yearDayIndex",doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockclearYearDayScheduleCommandParams.put("userIndex",doorLockclearYearDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockclearYearDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearYearDaySchedule((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("yearDayIndex") + , (Integer) + commandArguments.get("userIndex") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearYearDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("clearYearDaySchedule", doorLockclearYearDayScheduleInteractionInfo); + Map doorLockgetCredentialStatusCommandParams = new LinkedHashMap(); + InteractionInfo doorLockgetCredentialStatusInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getCredentialStatus((ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback + , (ChipStructs.DoorLockClusterDlCredential) + commandArguments.get("credential") + + ); + }, + () -> new DelegatedGetCredentialStatusResponseCallback(), + doorLockgetCredentialStatusCommandParams + ); + doorLockClusterInteractionInfoMap.put("getCredentialStatus", doorLockgetCredentialStatusInteractionInfo); + Map doorLockgetUserCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockgetUserCommandParams.put("userIndex",doorLockgetUseruserIndexCommandParameterInfo); + + InteractionInfo doorLockgetUserInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getUser((ChipClusters.DoorLockCluster.GetUserResponseCallback) callback + , (Integer) + commandArguments.get("userIndex") + + ); + }, + () -> new DelegatedGetUserResponseCallback(), + doorLockgetUserCommandParams + ); + doorLockClusterInteractionInfoMap.put("getUser", doorLockgetUserInteractionInfo); + Map doorLockgetWeekDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); + doorLockgetWeekDayScheduleCommandParams.put("weekDayIndex",doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockgetWeekDayScheduleCommandParams.put("userIndex",doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getWeekDaySchedule((ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback) callback + , (Integer) + commandArguments.get("weekDayIndex") + , (Integer) + commandArguments.get("userIndex") + + ); + }, + () -> new DelegatedGetWeekDayScheduleResponseCallback(), + doorLockgetWeekDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("getWeekDaySchedule", doorLockgetWeekDayScheduleInteractionInfo); + Map doorLockgetYearDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); + doorLockgetYearDayScheduleCommandParams.put("yearDayIndex",doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLockgetYearDayScheduleCommandParams.put("userIndex",doorLockgetYearDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockgetYearDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getYearDaySchedule((ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback) callback + , (Integer) + commandArguments.get("yearDayIndex") + , (Integer) + commandArguments.get("userIndex") + + ); + }, + () -> new DelegatedGetYearDayScheduleResponseCallback(), + doorLockgetYearDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("getYearDaySchedule", doorLockgetYearDayScheduleInteractionInfo); + Map doorLocklockDoorCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); + doorLocklockDoorCommandParams.put("pinCode",doorLocklockDoorpinCodeCommandParameterInfo); + + InteractionInfo doorLocklockDoorInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .lockDoor((DefaultClusterCallback) callback + , (Optional) + commandArguments.get("pinCode") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocklockDoorCommandParams + ); + doorLockClusterInteractionInfoMap.put("lockDoor", doorLocklockDoorInteractionInfo); + Map doorLocksetCredentialCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); + doorLocksetCredentialCommandParams.put("operationType",doorLocksetCredentialoperationTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = new CommandParameterInfo("credentialData", byte[].class); + doorLocksetCredentialCommandParams.put("credentialData",doorLocksetCredentialcredentialDataCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLocksetCredentialCommandParams.put("userIndex",doorLocksetCredentialuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); + doorLocksetCredentialCommandParams.put("userStatus",doorLocksetCredentialuserStatusCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); + doorLocksetCredentialCommandParams.put("userType",doorLocksetCredentialuserTypeCommandParameterInfo); + + InteractionInfo doorLocksetCredentialInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setCredential((ChipClusters.DoorLockCluster.SetCredentialResponseCallback) callback + , (Integer) + commandArguments.get("operationType") + , (ChipStructs.DoorLockClusterDlCredential) + commandArguments.get("credential") + , (byte[]) + commandArguments.get("credentialData") + , (Integer) + commandArguments.get("userIndex") + , (Integer) + commandArguments.get("userStatus") + , (Integer) + commandArguments.get("userType") + , 10000 + ); + }, + () -> new DelegatedSetCredentialResponseCallback(), + doorLocksetCredentialCommandParams + ); + doorLockClusterInteractionInfoMap.put("setCredential", doorLocksetCredentialInteractionInfo); + Map doorLocksetUserCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); + doorLocksetUserCommandParams.put("operationType",doorLocksetUseroperationTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLocksetUserCommandParams.put("userIndex",doorLocksetUseruserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = new CommandParameterInfo("userName", String.class); + doorLocksetUserCommandParams.put("userName",doorLocksetUseruserNameCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = new CommandParameterInfo("userUniqueId", Long.class); + doorLocksetUserCommandParams.put("userUniqueId",doorLocksetUseruserUniqueIdCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); + doorLocksetUserCommandParams.put("userStatus",doorLocksetUseruserStatusCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); + doorLocksetUserCommandParams.put("userType",doorLocksetUseruserTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = new CommandParameterInfo("credentialRule", Integer.class); + doorLocksetUserCommandParams.put("credentialRule",doorLocksetUsercredentialRuleCommandParameterInfo); + + InteractionInfo doorLocksetUserInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setUser((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("operationType") + , (Integer) + commandArguments.get("userIndex") + , (String) + commandArguments.get("userName") + , (Long) + commandArguments.get("userUniqueId") + , (Integer) + commandArguments.get("userStatus") + , (Integer) + commandArguments.get("userType") + , (Integer) + commandArguments.get("credentialRule") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetUserCommandParams + ); + doorLockClusterInteractionInfoMap.put("setUser", doorLocksetUserInteractionInfo); + Map doorLocksetWeekDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("weekDayIndex",doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("userIndex",doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = new CommandParameterInfo("daysMask", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("daysMask",doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = new CommandParameterInfo("startHour", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("startHour",doorLocksetWeekDaySchedulestartHourCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = new CommandParameterInfo("startMinute", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("startMinute",doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = new CommandParameterInfo("endHour", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("endHour",doorLocksetWeekDayScheduleendHourCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = new CommandParameterInfo("endMinute", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put("endMinute",doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); + + InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setWeekDaySchedule((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("weekDayIndex") + , (Integer) + commandArguments.get("userIndex") + , (Integer) + commandArguments.get("daysMask") + , (Integer) + commandArguments.get("startHour") + , (Integer) + commandArguments.get("startMinute") + , (Integer) + commandArguments.get("endHour") + , (Integer) + commandArguments.get("endMinute") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetWeekDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("setWeekDaySchedule", doorLocksetWeekDayScheduleInteractionInfo); + Map doorLocksetYearDayScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); + doorLocksetYearDayScheduleCommandParams.put("yearDayIndex",doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); + doorLocksetYearDayScheduleCommandParams.put("userIndex",doorLocksetYearDayScheduleuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = new CommandParameterInfo("localStartTime", Long.class); + doorLocksetYearDayScheduleCommandParams.put("localStartTime",doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = new CommandParameterInfo("localEndTime", Long.class); + doorLocksetYearDayScheduleCommandParams.put("localEndTime",doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); + + InteractionInfo doorLocksetYearDayScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setYearDaySchedule((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("yearDayIndex") + , (Integer) + commandArguments.get("userIndex") + , (Long) + commandArguments.get("localStartTime") + , (Long) + commandArguments.get("localEndTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetYearDayScheduleCommandParams + ); + doorLockClusterInteractionInfoMap.put("setYearDaySchedule", doorLocksetYearDayScheduleInteractionInfo); + Map doorLockunlockDoorCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); + doorLockunlockDoorCommandParams.put("pinCode",doorLockunlockDoorpinCodeCommandParameterInfo); + + InteractionInfo doorLockunlockDoorInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .unlockDoor((DefaultClusterCallback) callback + , (Optional) + commandArguments.get("pinCode") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockunlockDoorCommandParams + ); + doorLockClusterInteractionInfoMap.put("unlockDoor", doorLockunlockDoorInteractionInfo); + Map doorLockunlockWithTimeoutCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = new CommandParameterInfo("timeout", Integer.class); + doorLockunlockWithTimeoutCommandParams.put("timeout",doorLockunlockWithTimeouttimeoutCommandParameterInfo); + + CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); + doorLockunlockWithTimeoutCommandParams.put("pinCode",doorLockunlockWithTimeoutpinCodeCommandParameterInfo); + + InteractionInfo doorLockunlockWithTimeoutInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .unlockWithTimeout((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("timeout") + , (Optional) + commandArguments.get("pinCode") + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockunlockWithTimeoutCommandParams + ); + doorLockClusterInteractionInfoMap.put("unlockWithTimeout", doorLockunlockWithTimeoutInteractionInfo); + commandMap.put("doorLock", doorLockClusterInteractionInfoMap); + Map electricalMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("electricalMeasurement", electricalMeasurementClusterInteractionInfoMap); + Map ethernetNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map ethernetNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); + InteractionInfo ethernetNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + ethernetNetworkDiagnosticsresetCountsCommandParams + ); + ethernetNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", ethernetNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); + Map fixedLabelClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("fixedLabel", fixedLabelClusterInteractionInfoMap); + Map flowMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("flowMeasurement", flowMeasurementClusterInteractionInfoMap); + Map generalCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); + Map generalCommissioningarmFailSafeCommandParams = new LinkedHashMap(); + CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = new CommandParameterInfo("expiryLengthSeconds", Integer.class); + generalCommissioningarmFailSafeCommandParams.put("expiryLengthSeconds",generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); + + CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + generalCommissioningarmFailSafeCommandParams.put("breadcrumb",generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); + + CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); + generalCommissioningarmFailSafeCommandParams.put("timeoutMs",generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); + + InteractionInfo generalCommissioningarmFailSafeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .armFailSafe((ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback) callback + , (Integer) + commandArguments.get("expiryLengthSeconds") + , (Long) + commandArguments.get("breadcrumb") + , (Long) + commandArguments.get("timeoutMs") + + ); + }, + () -> new DelegatedArmFailSafeResponseCallback(), + generalCommissioningarmFailSafeCommandParams + ); + generalCommissioningClusterInteractionInfoMap.put("armFailSafe", generalCommissioningarmFailSafeInteractionInfo); + Map generalCommissioningcommissioningCompleteCommandParams = new LinkedHashMap(); + InteractionInfo generalCommissioningcommissioningCompleteInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .commissioningComplete((ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback) callback + + ); + }, + () -> new DelegatedCommissioningCompleteResponseCallback(), + generalCommissioningcommissioningCompleteCommandParams + ); + generalCommissioningClusterInteractionInfoMap.put("commissioningComplete", generalCommissioningcommissioningCompleteInteractionInfo); + Map generalCommissioningsetRegulatoryConfigCommandParams = new LinkedHashMap(); + CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = new CommandParameterInfo("location", Integer.class); + generalCommissioningsetRegulatoryConfigCommandParams.put("location",generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = new CommandParameterInfo("countryCode", String.class); + generalCommissioningsetRegulatoryConfigCommandParams.put("countryCode",generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + generalCommissioningsetRegulatoryConfigCommandParams.put("breadcrumb",generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); + generalCommissioningsetRegulatoryConfigCommandParams.put("timeoutMs",generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); + + InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .setRegulatoryConfig((ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback) callback + , (Integer) + commandArguments.get("location") + , (String) + commandArguments.get("countryCode") + , (Long) + commandArguments.get("breadcrumb") + , (Long) + commandArguments.get("timeoutMs") + + ); + }, + () -> new DelegatedSetRegulatoryConfigResponseCallback(), + generalCommissioningsetRegulatoryConfigCommandParams + ); + generalCommissioningClusterInteractionInfoMap.put("setRegulatoryConfig", generalCommissioningsetRegulatoryConfigInteractionInfo); + commandMap.put("generalCommissioning", generalCommissioningClusterInteractionInfoMap); + Map generalDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("generalDiagnostics", generalDiagnosticsClusterInteractionInfoMap); + Map groupKeyManagementClusterInteractionInfoMap = new LinkedHashMap<>(); + Map groupKeyManagementkeySetReadCommandParams = new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); + groupKeyManagementkeySetReadCommandParams.put("groupKeySetID",groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetReadInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetRead((ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback + , (Integer) + commandArguments.get("groupKeySetID") + + ); + }, + () -> new DelegatedKeySetReadResponseCallback(), + groupKeyManagementkeySetReadCommandParams + ); + groupKeyManagementClusterInteractionInfoMap.put("keySetRead", groupKeyManagementkeySetReadInteractionInfo); + Map groupKeyManagementkeySetReadAllIndicesCommandParams = new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = new CommandParameterInfo("groupKeySetIDs", ArrayList.class); + groupKeyManagementkeySetReadAllIndicesCommandParams.put("groupKeySetIDs",groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetReadAllIndices((ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) callback + , (ArrayList) + commandArguments.get("groupKeySetIDs") + + ); + }, + () -> new DelegatedKeySetReadAllIndicesResponseCallback(), + groupKeyManagementkeySetReadAllIndicesCommandParams + ); + groupKeyManagementClusterInteractionInfoMap.put("keySetReadAllIndices", groupKeyManagementkeySetReadAllIndicesInteractionInfo); + Map groupKeyManagementkeySetRemoveCommandParams = new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); + groupKeyManagementkeySetRemoveCommandParams.put("groupKeySetID",groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetRemove((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("groupKeySetID") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + groupKeyManagementkeySetRemoveCommandParams + ); + groupKeyManagementClusterInteractionInfoMap.put("keySetRemove", groupKeyManagementkeySetRemoveInteractionInfo); + Map groupKeyManagementkeySetWriteCommandParams = new LinkedHashMap(); + InteractionInfo groupKeyManagementkeySetWriteInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetWrite((DefaultClusterCallback) callback + , (ChipStructs.GroupKeyManagementClusterGroupKeySet) + commandArguments.get("groupKeySet") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + groupKeyManagementkeySetWriteCommandParams + ); + groupKeyManagementClusterInteractionInfoMap.put("keySetWrite", groupKeyManagementkeySetWriteInteractionInfo); + commandMap.put("groupKeyManagement", groupKeyManagementClusterInteractionInfoMap); + Map groupsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map groupsaddGroupCommandParams = new LinkedHashMap(); + CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + groupsaddGroupCommandParams.put("groupId",groupsaddGroupgroupIdCommandParameterInfo); + + CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); + groupsaddGroupCommandParams.put("groupName",groupsaddGroupgroupNameCommandParameterInfo); + + InteractionInfo groupsaddGroupInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .addGroup((ChipClusters.GroupsCluster.AddGroupResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + , (String) + commandArguments.get("groupName") + + ); + }, + () -> new DelegatedAddGroupResponseCallback(), + groupsaddGroupCommandParams + ); + groupsClusterInteractionInfoMap.put("addGroup", groupsaddGroupInteractionInfo); + Map groupsaddGroupIfIdentifyingCommandParams = new LinkedHashMap(); + CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + groupsaddGroupIfIdentifyingCommandParams.put("groupId",groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); + + CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); + groupsaddGroupIfIdentifyingCommandParams.put("groupName",groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); + + InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .addGroupIfIdentifying((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("groupId") + , (String) + commandArguments.get("groupName") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + groupsaddGroupIfIdentifyingCommandParams + ); + groupsClusterInteractionInfoMap.put("addGroupIfIdentifying", groupsaddGroupIfIdentifyingInteractionInfo); + Map groupsgetGroupMembershipCommandParams = new LinkedHashMap(); + CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = new CommandParameterInfo("groupList", ArrayList.class); + groupsgetGroupMembershipCommandParams.put("groupList",groupsgetGroupMembershipgroupListCommandParameterInfo); + + InteractionInfo groupsgetGroupMembershipInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .getGroupMembership((ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback + , (ArrayList) + commandArguments.get("groupList") + + ); + }, + () -> new DelegatedGetGroupMembershipResponseCallback(), + groupsgetGroupMembershipCommandParams + ); + groupsClusterInteractionInfoMap.put("getGroupMembership", groupsgetGroupMembershipInteractionInfo); + Map groupsremoveAllGroupsCommandParams = new LinkedHashMap(); + InteractionInfo groupsremoveAllGroupsInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .removeAllGroups((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + groupsremoveAllGroupsCommandParams + ); + groupsClusterInteractionInfoMap.put("removeAllGroups", groupsremoveAllGroupsInteractionInfo); + Map groupsremoveGroupCommandParams = new LinkedHashMap(); + CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + groupsremoveGroupCommandParams.put("groupId",groupsremoveGroupgroupIdCommandParameterInfo); + + InteractionInfo groupsremoveGroupInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .removeGroup((ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + + ); + }, + () -> new DelegatedRemoveGroupResponseCallback(), + groupsremoveGroupCommandParams + ); + groupsClusterInteractionInfoMap.put("removeGroup", groupsremoveGroupInteractionInfo); + Map groupsviewGroupCommandParams = new LinkedHashMap(); + CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + groupsviewGroupCommandParams.put("groupId",groupsviewGroupgroupIdCommandParameterInfo); + + InteractionInfo groupsviewGroupInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .viewGroup((ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + + ); + }, + () -> new DelegatedViewGroupResponseCallback(), + groupsviewGroupCommandParams + ); + groupsClusterInteractionInfoMap.put("viewGroup", groupsviewGroupInteractionInfo); + commandMap.put("groups", groupsClusterInteractionInfoMap); + Map identifyClusterInteractionInfoMap = new LinkedHashMap<>(); + Map identifyidentifyCommandParams = new LinkedHashMap(); + CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("identifyTime", Integer.class); + identifyidentifyCommandParams.put("identifyTime",identifyidentifyidentifyTimeCommandParameterInfo); + + InteractionInfo identifyidentifyInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .identify((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("identifyTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + identifyidentifyCommandParams + ); + identifyClusterInteractionInfoMap.put("identify", identifyidentifyInteractionInfo); + Map identifyidentifyQueryCommandParams = new LinkedHashMap(); + InteractionInfo identifyidentifyQueryInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .identifyQuery((ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback + + ); + }, + () -> new DelegatedIdentifyQueryResponseCallback(), + identifyidentifyQueryCommandParams + ); + identifyClusterInteractionInfoMap.put("identifyQuery", identifyidentifyQueryInteractionInfo); + Map identifytriggerEffectCommandParams = new LinkedHashMap(); + CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = new CommandParameterInfo("effectIdentifier", Integer.class); + identifytriggerEffectCommandParams.put("effectIdentifier",identifytriggerEffecteffectIdentifierCommandParameterInfo); + + CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); + identifytriggerEffectCommandParams.put("effectVariant",identifytriggerEffecteffectVariantCommandParameterInfo); + + InteractionInfo identifytriggerEffectInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .triggerEffect((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("effectIdentifier") + , (Integer) + commandArguments.get("effectVariant") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + identifytriggerEffectCommandParams + ); + identifyClusterInteractionInfoMap.put("triggerEffect", identifytriggerEffectInteractionInfo); + commandMap.put("identify", identifyClusterInteractionInfoMap); + Map illuminanceMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInteractionInfoMap); + Map keypadInputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map keypadInputsendKeyRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = new CommandParameterInfo("keyCode", Integer.class); + keypadInputsendKeyRequestCommandParams.put("keyCode",keypadInputsendKeyRequestkeyCodeCommandParameterInfo); + + InteractionInfo keypadInputsendKeyRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .sendKeyRequest((ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback + , (Integer) + commandArguments.get("keyCode") + + ); + }, + () -> new DelegatedSendKeyResponseCallback(), + keypadInputsendKeyRequestCommandParams + ); + keypadInputClusterInteractionInfoMap.put("sendKeyRequest", keypadInputsendKeyRequestInteractionInfo); + commandMap.put("keypadInput", keypadInputClusterInteractionInfoMap); + Map levelControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map levelControlmoveCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + levelControlmoveCommandParams.put("moveMode",levelControlmovemoveModeCommandParameterInfo); + + CommandParameterInfo levelControlmoverateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + levelControlmoveCommandParams.put("rate",levelControlmoverateCommandParameterInfo); + + CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); + levelControlmoveCommandParams.put("optionMask",levelControlmoveoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); + levelControlmoveCommandParams.put("optionOverride",levelControlmoveoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlmoveInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .move((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + , (Integer) + commandArguments.get("optionMask") + , (Integer) + commandArguments.get("optionOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveCommandParams + ); + levelControlClusterInteractionInfoMap.put("move", levelControlmoveInteractionInfo); + Map levelControlmoveToLevelCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); + levelControlmoveToLevelCommandParams.put("level",levelControlmoveToLevellevelCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + levelControlmoveToLevelCommandParams.put("transitionTime",levelControlmoveToLeveltransitionTimeCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); + levelControlmoveToLevelCommandParams.put("optionMask",levelControlmoveToLeveloptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); + levelControlmoveToLevelCommandParams.put("optionOverride",levelControlmoveToLeveloptionOverrideCommandParameterInfo); + + InteractionInfo levelControlmoveToLevelInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveToLevel((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("level") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionMask") + , (Integer) + commandArguments.get("optionOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveToLevelCommandParams + ); + levelControlClusterInteractionInfoMap.put("moveToLevel", levelControlmoveToLevelInteractionInfo); + Map levelControlmoveToLevelWithOnOffCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); + levelControlmoveToLevelWithOnOffCommandParams.put("level",levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + levelControlmoveToLevelWithOnOffCommandParams.put("transitionTime",levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); + + InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveToLevelWithOnOff((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("level") + , (Integer) + commandArguments.get("transitionTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveToLevelWithOnOffCommandParams + ); + levelControlClusterInteractionInfoMap.put("moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffInteractionInfo); + Map levelControlmoveWithOnOffCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); + levelControlmoveWithOnOffCommandParams.put("moveMode",levelControlmoveWithOnOffmoveModeCommandParameterInfo); + + CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); + levelControlmoveWithOnOffCommandParams.put("rate",levelControlmoveWithOnOffrateCommandParameterInfo); + + InteractionInfo levelControlmoveWithOnOffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveWithOnOff((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("moveMode") + , (Integer) + commandArguments.get("rate") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveWithOnOffCommandParams + ); + levelControlClusterInteractionInfoMap.put("moveWithOnOff", levelControlmoveWithOnOffInteractionInfo); + Map levelControlstepCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlstepstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + levelControlstepCommandParams.put("stepMode",levelControlstepstepModeCommandParameterInfo); + + CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + levelControlstepCommandParams.put("stepSize",levelControlstepstepSizeCommandParameterInfo); + + CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + levelControlstepCommandParams.put("transitionTime",levelControlsteptransitionTimeCommandParameterInfo); + + CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); + levelControlstepCommandParams.put("optionMask",levelControlstepoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); + levelControlstepCommandParams.put("optionOverride",levelControlstepoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlstepInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .step((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + , (Integer) + commandArguments.get("optionMask") + , (Integer) + commandArguments.get("optionOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstepCommandParams + ); + levelControlClusterInteractionInfoMap.put("step", levelControlstepInteractionInfo); + Map levelControlstepWithOnOffCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); + levelControlstepWithOnOffCommandParams.put("stepMode",levelControlstepWithOnOffstepModeCommandParameterInfo); + + CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); + levelControlstepWithOnOffCommandParams.put("stepSize",levelControlstepWithOnOffstepSizeCommandParameterInfo); + + CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + levelControlstepWithOnOffCommandParams.put("transitionTime",levelControlstepWithOnOfftransitionTimeCommandParameterInfo); + + InteractionInfo levelControlstepWithOnOffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stepWithOnOff((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("stepMode") + , (Integer) + commandArguments.get("stepSize") + , (Integer) + commandArguments.get("transitionTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstepWithOnOffCommandParams + ); + levelControlClusterInteractionInfoMap.put("stepWithOnOff", levelControlstepWithOnOffInteractionInfo); + Map levelControlstopCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); + levelControlstopCommandParams.put("optionMask",levelControlstopoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); + levelControlstopCommandParams.put("optionOverride",levelControlstopoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlstopInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stop((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("optionMask") + , (Integer) + commandArguments.get("optionOverride") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstopCommandParams + ); + levelControlClusterInteractionInfoMap.put("stop", levelControlstopInteractionInfo); + Map levelControlstopWithOnOffCommandParams = new LinkedHashMap(); + InteractionInfo levelControlstopWithOnOffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stopWithOnOff((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstopWithOnOffCommandParams + ); + levelControlClusterInteractionInfoMap.put("stopWithOnOff", levelControlstopWithOnOffInteractionInfo); + commandMap.put("levelControl", levelControlClusterInteractionInfoMap); + Map localizationConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("localizationConfiguration", localizationConfigurationClusterInteractionInfoMap); + Map lowPowerClusterInteractionInfoMap = new LinkedHashMap<>(); + Map lowPowersleepCommandParams = new LinkedHashMap(); + InteractionInfo lowPowersleepInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .sleep((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + lowPowersleepCommandParams + ); + lowPowerClusterInteractionInfoMap.put("sleep", lowPowersleepInteractionInfo); + commandMap.put("lowPower", lowPowerClusterInteractionInfoMap); + Map mediaInputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map mediaInputhideInputStatusRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaInputhideInputStatusRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .hideInputStatusRequest((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputhideInputStatusRequestCommandParams + ); + mediaInputClusterInteractionInfoMap.put("hideInputStatusRequest", mediaInputhideInputStatusRequestInteractionInfo); + Map mediaInputrenameInputRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); + mediaInputrenameInputRequestCommandParams.put("index",mediaInputrenameInputRequestindexCommandParameterInfo); + + CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); + mediaInputrenameInputRequestCommandParams.put("name",mediaInputrenameInputRequestnameCommandParameterInfo); + + InteractionInfo mediaInputrenameInputRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .renameInputRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("index") + , (String) + commandArguments.get("name") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputrenameInputRequestCommandParams + ); + mediaInputClusterInteractionInfoMap.put("renameInputRequest", mediaInputrenameInputRequestInteractionInfo); + Map mediaInputselectInputRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); + mediaInputselectInputRequestCommandParams.put("index",mediaInputselectInputRequestindexCommandParameterInfo); + + InteractionInfo mediaInputselectInputRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .selectInputRequest((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("index") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputselectInputRequestCommandParams + ); + mediaInputClusterInteractionInfoMap.put("selectInputRequest", mediaInputselectInputRequestInteractionInfo); + Map mediaInputshowInputStatusRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaInputshowInputStatusRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .showInputStatusRequest((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputshowInputStatusRequestCommandParams + ); + mediaInputClusterInteractionInfoMap.put("showInputStatusRequest", mediaInputshowInputStatusRequestInteractionInfo); + commandMap.put("mediaInput", mediaInputClusterInteractionInfoMap); + Map mediaPlaybackClusterInteractionInfoMap = new LinkedHashMap<>(); + Map mediaPlaybackfastForwardRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackfastForwardRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .fastForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackfastForwardRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("fastForwardRequest", mediaPlaybackfastForwardRequestInteractionInfo); + Map mediaPlaybacknextRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybacknextRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .nextRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybacknextRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("nextRequest", mediaPlaybacknextRequestInteractionInfo); + Map mediaPlaybackpauseRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackpauseRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .pauseRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackpauseRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("pauseRequest", mediaPlaybackpauseRequestInteractionInfo); + Map mediaPlaybackplayRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackplayRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .playRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackplayRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("playRequest", mediaPlaybackplayRequestInteractionInfo); + Map mediaPlaybackpreviousRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackpreviousRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .previousRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackpreviousRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("previousRequest", mediaPlaybackpreviousRequestInteractionInfo); + Map mediaPlaybackrewindRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackrewindRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .rewindRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackrewindRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("rewindRequest", mediaPlaybackrewindRequestInteractionInfo); + Map mediaPlaybackseekRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = new CommandParameterInfo("position", Long.class); + mediaPlaybackseekRequestCommandParams.put("position",mediaPlaybackseekRequestpositionCommandParameterInfo); + + InteractionInfo mediaPlaybackseekRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .seekRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + , (Long) + commandArguments.get("position") + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackseekRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("seekRequest", mediaPlaybackseekRequestInteractionInfo); + Map mediaPlaybackskipBackwardRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); + mediaPlaybackskipBackwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); + + InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .skipBackwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + , (Long) + commandArguments.get("deltaPositionMilliseconds") + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackskipBackwardRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("skipBackwardRequest", mediaPlaybackskipBackwardRequestInteractionInfo); + Map mediaPlaybackskipForwardRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); + mediaPlaybackskipForwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); + + InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .skipForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + , (Long) + commandArguments.get("deltaPositionMilliseconds") + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackskipForwardRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("skipForwardRequest", mediaPlaybackskipForwardRequestInteractionInfo); + Map mediaPlaybackstartOverRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackstartOverRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .startOverRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackstartOverRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("startOverRequest", mediaPlaybackstartOverRequestInteractionInfo); + Map mediaPlaybackstopRequestCommandParams = new LinkedHashMap(); + InteractionInfo mediaPlaybackstopRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .stopRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback + + ); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackstopRequestCommandParams + ); + mediaPlaybackClusterInteractionInfoMap.put("stopRequest", mediaPlaybackstopRequestInteractionInfo); + commandMap.put("mediaPlayback", mediaPlaybackClusterInteractionInfoMap); + Map modeSelectClusterInteractionInfoMap = new LinkedHashMap<>(); + Map modeSelectchangeToModeCommandParams = new LinkedHashMap(); + CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = new CommandParameterInfo("newMode", Integer.class); + modeSelectchangeToModeCommandParams.put("newMode",modeSelectchangeToModenewModeCommandParameterInfo); + + InteractionInfo modeSelectchangeToModeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .changeToMode((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("newMode") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + modeSelectchangeToModeCommandParams + ); + modeSelectClusterInteractionInfoMap.put("changeToMode", modeSelectchangeToModeInteractionInfo); + commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); + Map networkCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); + Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = new CommandParameterInfo("operationalDataset", byte[].class); + networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("operationalDataset",networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .addOrUpdateThreadNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback + , (byte[]) + commandArguments.get("operationalDataset") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningaddOrUpdateThreadNetworkCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("addOrUpdateThreadNetwork", networkCommissioningaddOrUpdateThreadNetworkInteractionInfo); + Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("ssid",networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = new CommandParameterInfo("credentials", byte[].class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("credentials",networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .addOrUpdateWiFiNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback + , (byte[]) + commandArguments.get("ssid") + , (byte[]) + commandArguments.get("credentials") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningaddOrUpdateWiFiNetworkCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("addOrUpdateWiFiNetwork", networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo); + Map networkCommissioningconnectNetworkCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); + networkCommissioningconnectNetworkCommandParams.put("networkID",networkCommissioningconnectNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningconnectNetworkCommandParams.put("breadcrumb",networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningconnectNetworkInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .connectNetwork((ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback) callback + , (byte[]) + commandArguments.get("networkID") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedConnectNetworkResponseCallback(), + networkCommissioningconnectNetworkCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("connectNetwork", networkCommissioningconnectNetworkInteractionInfo); + Map networkCommissioningremoveNetworkCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); + networkCommissioningremoveNetworkCommandParams.put("networkID",networkCommissioningremoveNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningremoveNetworkCommandParams.put("breadcrumb",networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningremoveNetworkInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .removeNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback + , (byte[]) + commandArguments.get("networkID") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningremoveNetworkCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("removeNetwork", networkCommissioningremoveNetworkInteractionInfo); + Map networkCommissioningreorderNetworkCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); + networkCommissioningreorderNetworkCommandParams.put("networkID",networkCommissioningreorderNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = new CommandParameterInfo("networkIndex", Integer.class); + networkCommissioningreorderNetworkCommandParams.put("networkIndex",networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); + + CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningreorderNetworkCommandParams.put("breadcrumb",networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningreorderNetworkInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .reorderNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback + , (byte[]) + commandArguments.get("networkID") + , (Integer) + commandArguments.get("networkIndex") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningreorderNetworkCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("reorderNetwork", networkCommissioningreorderNetworkInteractionInfo); + Map networkCommissioningscanNetworksCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); + networkCommissioningscanNetworksCommandParams.put("ssid",networkCommissioningscanNetworksssidCommandParameterInfo); + + CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningscanNetworksCommandParams.put("breadcrumb",networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningscanNetworksInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .scanNetworks((ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback) callback + , (byte[]) + commandArguments.get("ssid") + , (Long) + commandArguments.get("breadcrumb") + + ); + }, + () -> new DelegatedScanNetworksResponseCallback(), + networkCommissioningscanNetworksCommandParams + ); + networkCommissioningClusterInteractionInfoMap.put("scanNetworks", networkCommissioningscanNetworksInteractionInfo); + commandMap.put("networkCommissioning", networkCommissioningClusterInteractionInfoMap); + Map otaSoftwareUpdateProviderClusterInteractionInfoMap = new LinkedHashMap<>(); + Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("updateToken",otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = new CommandParameterInfo("newVersion", Long.class); + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("newVersion",otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .applyUpdateRequest((ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback) callback + , (byte[]) + commandArguments.get("updateToken") + , (Long) + commandArguments.get("newVersion") + + ); + }, + () -> new DelegatedApplyUpdateResponseCallback(), + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams + ); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put("applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo); + Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = new LinkedHashMap(); + CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("updateToken",otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("softwareVersion",otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .notifyUpdateApplied((DefaultClusterCallback) callback + , (byte[]) + commandArguments.get("updateToken") + , (Long) + commandArguments.get("softwareVersion") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams + ); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put("notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo); + Map otaSoftwareUpdateProviderqueryImageCommandParams = new LinkedHashMap(); + CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("vendorId",otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = new CommandParameterInfo("productId", Integer.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("productId",otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("softwareVersion",otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = new CommandParameterInfo("protocolsSupported", ArrayList.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("protocolsSupported",otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = new CommandParameterInfo("hardwareVersion", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("hardwareVersion",otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = new CommandParameterInfo("location", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("location",otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = new CommandParameterInfo("requestorCanConsent", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("requestorCanConsent",otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = new CommandParameterInfo("metadataForProvider", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put("metadataForProvider",otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .queryImage((ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback) callback + , (Integer) + commandArguments.get("vendorId") + , (Integer) + commandArguments.get("productId") + , (Long) + commandArguments.get("softwareVersion") + , (ArrayList) + commandArguments.get("protocolsSupported") + , (Optional) + commandArguments.get("hardwareVersion") + , (Optional) + commandArguments.get("location") + , (Optional) + commandArguments.get("requestorCanConsent") + , (Optional) + commandArguments.get("metadataForProvider") + + ); + }, + () -> new DelegatedQueryImageResponseCallback(), + otaSoftwareUpdateProviderqueryImageCommandParams + ); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put("queryImage", otaSoftwareUpdateProviderqueryImageInteractionInfo); + commandMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInteractionInfoMap); + Map otaSoftwareUpdateRequestorClusterInteractionInfoMap = new LinkedHashMap<>(); + Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = new LinkedHashMap(); + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = new CommandParameterInfo("providerNodeId", Long.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("providerNodeId",otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("vendorId",otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = new CommandParameterInfo("announcementReason", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("announcementReason",otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = new CommandParameterInfo("metadataForNode", Optional.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("metadataForNode",otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = new CommandParameterInfo("endpoint", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("endpoint",otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .announceOtaProvider((DefaultClusterCallback) callback + , (Long) + commandArguments.get("providerNodeId") + , (Integer) + commandArguments.get("vendorId") + , (Integer) + commandArguments.get("announcementReason") + , (Optional) + commandArguments.get("metadataForNode") + , (Integer) + commandArguments.get("endpoint") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams + ); + otaSoftwareUpdateRequestorClusterInteractionInfoMap.put("announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo); + commandMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInteractionInfoMap); + Map occupancySensingClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("occupancySensing", occupancySensingClusterInteractionInfoMap); + Map onOffClusterInteractionInfoMap = new LinkedHashMap<>(); + Map onOffoffCommandParams = new LinkedHashMap(); + InteractionInfo onOffoffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .off((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffoffCommandParams + ); + onOffClusterInteractionInfoMap.put("off", onOffoffInteractionInfo); + Map onOffoffWithEffectCommandParams = new LinkedHashMap(); + CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = new CommandParameterInfo("effectId", Integer.class); + onOffoffWithEffectCommandParams.put("effectId",onOffoffWithEffecteffectIdCommandParameterInfo); + + CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); + onOffoffWithEffectCommandParams.put("effectVariant",onOffoffWithEffecteffectVariantCommandParameterInfo); + + InteractionInfo onOffoffWithEffectInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .offWithEffect((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("effectId") + , (Integer) + commandArguments.get("effectVariant") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffoffWithEffectCommandParams + ); + onOffClusterInteractionInfoMap.put("offWithEffect", onOffoffWithEffectInteractionInfo); + Map onOffonCommandParams = new LinkedHashMap(); + InteractionInfo onOffonInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .on((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonCommandParams + ); + onOffClusterInteractionInfoMap.put("on", onOffonInteractionInfo); + Map onOffonWithRecallGlobalSceneCommandParams = new LinkedHashMap(); + InteractionInfo onOffonWithRecallGlobalSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .onWithRecallGlobalScene((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonWithRecallGlobalSceneCommandParams + ); + onOffClusterInteractionInfoMap.put("onWithRecallGlobalScene", onOffonWithRecallGlobalSceneInteractionInfo); + Map onOffonWithTimedOffCommandParams = new LinkedHashMap(); + CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = new CommandParameterInfo("onOffControl", Integer.class); + onOffonWithTimedOffCommandParams.put("onOffControl",onOffonWithTimedOffonOffControlCommandParameterInfo); + + CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = new CommandParameterInfo("onTime", Integer.class); + onOffonWithTimedOffCommandParams.put("onTime",onOffonWithTimedOffonTimeCommandParameterInfo); + + CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("offWaitTime", Integer.class); + onOffonWithTimedOffCommandParams.put("offWaitTime",onOffonWithTimedOffoffWaitTimeCommandParameterInfo); + + InteractionInfo onOffonWithTimedOffInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .onWithTimedOff((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("onOffControl") + , (Integer) + commandArguments.get("onTime") + , (Integer) + commandArguments.get("offWaitTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonWithTimedOffCommandParams + ); + onOffClusterInteractionInfoMap.put("onWithTimedOff", onOffonWithTimedOffInteractionInfo); + Map onOfftoggleCommandParams = new LinkedHashMap(); + InteractionInfo onOfftoggleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .toggle((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + onOfftoggleCommandParams + ); + onOffClusterInteractionInfoMap.put("toggle", onOfftoggleInteractionInfo); + commandMap.put("onOff", onOffClusterInteractionInfoMap); + Map onOffSwitchConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInteractionInfoMap); + Map operationalCredentialsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map operationalCredentialsaddNOCCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); + operationalCredentialsaddNOCCommandParams.put("NOCValue",operationalCredentialsaddNOCNOCValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); + operationalCredentialsaddNOCCommandParams.put("ICACValue",operationalCredentialsaddNOCICACValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = new CommandParameterInfo("IPKValue", byte[].class); + operationalCredentialsaddNOCCommandParams.put("IPKValue",operationalCredentialsaddNOCIPKValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = new CommandParameterInfo("caseAdminNode", Long.class); + operationalCredentialsaddNOCCommandParams.put("caseAdminNode",operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = new CommandParameterInfo("adminVendorId", Integer.class); + operationalCredentialsaddNOCCommandParams.put("adminVendorId",operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); + + InteractionInfo operationalCredentialsaddNOCInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .addNOC((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback + , (byte[]) + commandArguments.get("NOCValue") + , (Optional) + commandArguments.get("ICACValue") + , (byte[]) + commandArguments.get("IPKValue") + , (Long) + commandArguments.get("caseAdminNode") + , (Integer) + commandArguments.get("adminVendorId") + + ); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsaddNOCCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("addNOC", operationalCredentialsaddNOCInteractionInfo); + Map operationalCredentialsaddTrustedRootCertificateCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = new CommandParameterInfo("rootCertificate", byte[].class); + operationalCredentialsaddTrustedRootCertificateCommandParams.put("rootCertificate",operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); + + InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .addTrustedRootCertificate((DefaultClusterCallback) callback + , (byte[]) + commandArguments.get("rootCertificate") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + operationalCredentialsaddTrustedRootCertificateCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("addTrustedRootCertificate", operationalCredentialsaddTrustedRootCertificateInteractionInfo); + Map operationalCredentialsattestationRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = new CommandParameterInfo("attestationNonce", byte[].class); + operationalCredentialsattestationRequestCommandParams.put("attestationNonce",operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); + + InteractionInfo operationalCredentialsattestationRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .attestationRequest((ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) callback + , (byte[]) + commandArguments.get("attestationNonce") + + ); + }, + () -> new DelegatedAttestationResponseCallback(), + operationalCredentialsattestationRequestCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("attestationRequest", operationalCredentialsattestationRequestInteractionInfo); + Map operationalCredentialscertificateChainRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = new CommandParameterInfo("certificateType", Integer.class); + operationalCredentialscertificateChainRequestCommandParams.put("certificateType",operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); + + InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .certificateChainRequest((ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) callback + , (Integer) + commandArguments.get("certificateType") + + ); + }, + () -> new DelegatedCertificateChainResponseCallback(), + operationalCredentialscertificateChainRequestCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("certificateChainRequest", operationalCredentialscertificateChainRequestInteractionInfo); + Map operationalCredentialsopCSRRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = new CommandParameterInfo("CSRNonce", byte[].class); + operationalCredentialsopCSRRequestCommandParams.put("CSRNonce",operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); + + InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .opCSRRequest((ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback + , (byte[]) + commandArguments.get("CSRNonce") + + ); + }, + () -> new DelegatedOpCSRResponseCallback(), + operationalCredentialsopCSRRequestCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("opCSRRequest", operationalCredentialsopCSRRequestInteractionInfo); + Map operationalCredentialsremoveFabricCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = new CommandParameterInfo("fabricIndex", Integer.class); + operationalCredentialsremoveFabricCommandParams.put("fabricIndex",operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); + + InteractionInfo operationalCredentialsremoveFabricInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .removeFabric((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback + , (Integer) + commandArguments.get("fabricIndex") + + ); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsremoveFabricCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("removeFabric", operationalCredentialsremoveFabricInteractionInfo); + Map operationalCredentialsremoveTrustedRootCertificateCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = new CommandParameterInfo("trustedRootIdentifier", byte[].class); + operationalCredentialsremoveTrustedRootCertificateCommandParams.put("trustedRootIdentifier",operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); + + InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .removeTrustedRootCertificate((DefaultClusterCallback) callback + , (byte[]) + commandArguments.get("trustedRootIdentifier") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + operationalCredentialsremoveTrustedRootCertificateCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("removeTrustedRootCertificate", operationalCredentialsremoveTrustedRootCertificateInteractionInfo); + Map operationalCredentialsupdateFabricLabelCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = new CommandParameterInfo("label", String.class); + operationalCredentialsupdateFabricLabelCommandParams.put("label",operationalCredentialsupdateFabricLabellabelCommandParameterInfo); + + InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .updateFabricLabel((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback + , (String) + commandArguments.get("label") + + ); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsupdateFabricLabelCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("updateFabricLabel", operationalCredentialsupdateFabricLabelInteractionInfo); + Map operationalCredentialsupdateNOCCommandParams = new LinkedHashMap(); + CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); + operationalCredentialsupdateNOCCommandParams.put("NOCValue",operationalCredentialsupdateNOCNOCValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); + operationalCredentialsupdateNOCCommandParams.put("ICACValue",operationalCredentialsupdateNOCICACValueCommandParameterInfo); + + InteractionInfo operationalCredentialsupdateNOCInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .updateNOC((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback + , (byte[]) + commandArguments.get("NOCValue") + , (Optional) + commandArguments.get("ICACValue") + + ); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsupdateNOCCommandParams + ); + operationalCredentialsClusterInteractionInfoMap.put("updateNOC", operationalCredentialsupdateNOCInteractionInfo); + commandMap.put("operationalCredentials", operationalCredentialsClusterInteractionInfoMap); + Map powerSourceClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("powerSource", powerSourceClusterInteractionInfoMap); + Map powerSourceConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInteractionInfoMap); + Map pressureMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("pressureMeasurement", pressureMeasurementClusterInteractionInfoMap); + Map pumpConfigurationAndControlClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInteractionInfoMap); + Map relativeHumidityMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInteractionInfoMap); + Map scenesClusterInteractionInfoMap = new LinkedHashMap<>(); + Map scenesaddSceneCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesaddSceneCommandParams.put("groupId",scenesaddScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); + scenesaddSceneCommandParams.put("sceneId",scenesaddScenesceneIdCommandParameterInfo); + + CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + scenesaddSceneCommandParams.put("transitionTime",scenesaddScenetransitionTimeCommandParameterInfo); + + CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = new CommandParameterInfo("sceneName", String.class); + scenesaddSceneCommandParams.put("sceneName",scenesaddScenesceneNameCommandParameterInfo); + + InteractionInfo scenesaddSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .addScene((ChipClusters.ScenesCluster.AddSceneResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("sceneId") + , (Integer) + commandArguments.get("transitionTime") + , (String) + commandArguments.get("sceneName") + , (ArrayList) + commandArguments.get("extensionFieldSets") + + ); + }, + () -> new DelegatedAddSceneResponseCallback(), + scenesaddSceneCommandParams + ); + scenesClusterInteractionInfoMap.put("addScene", scenesaddSceneInteractionInfo); + Map scenesgetSceneMembershipCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesgetSceneMembershipCommandParams.put("groupId",scenesgetSceneMembershipgroupIdCommandParameterInfo); + + InteractionInfo scenesgetSceneMembershipInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .getSceneMembership((ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + + ); + }, + () -> new DelegatedGetSceneMembershipResponseCallback(), + scenesgetSceneMembershipCommandParams + ); + scenesClusterInteractionInfoMap.put("getSceneMembership", scenesgetSceneMembershipInteractionInfo); + Map scenesrecallSceneCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesrecallSceneCommandParams.put("groupId",scenesrecallScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); + scenesrecallSceneCommandParams.put("sceneId",scenesrecallScenesceneIdCommandParameterInfo); + + CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); + scenesrecallSceneCommandParams.put("transitionTime",scenesrecallScenetransitionTimeCommandParameterInfo); + + InteractionInfo scenesrecallSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .recallScene((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("sceneId") + , (Integer) + commandArguments.get("transitionTime") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + scenesrecallSceneCommandParams + ); + scenesClusterInteractionInfoMap.put("recallScene", scenesrecallSceneInteractionInfo); + Map scenesremoveAllScenesCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesremoveAllScenesCommandParams.put("groupId",scenesremoveAllScenesgroupIdCommandParameterInfo); + + InteractionInfo scenesremoveAllScenesInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .removeAllScenes((ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + + ); + }, + () -> new DelegatedRemoveAllScenesResponseCallback(), + scenesremoveAllScenesCommandParams + ); + scenesClusterInteractionInfoMap.put("removeAllScenes", scenesremoveAllScenesInteractionInfo); + Map scenesremoveSceneCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesremoveSceneCommandParams.put("groupId",scenesremoveScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); + scenesremoveSceneCommandParams.put("sceneId",scenesremoveScenesceneIdCommandParameterInfo); + + InteractionInfo scenesremoveSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .removeScene((ChipClusters.ScenesCluster.RemoveSceneResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("sceneId") + + ); + }, + () -> new DelegatedRemoveSceneResponseCallback(), + scenesremoveSceneCommandParams + ); + scenesClusterInteractionInfoMap.put("removeScene", scenesremoveSceneInteractionInfo); + Map scenesstoreSceneCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesstoreSceneCommandParams.put("groupId",scenesstoreScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); + scenesstoreSceneCommandParams.put("sceneId",scenesstoreScenesceneIdCommandParameterInfo); + + InteractionInfo scenesstoreSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .storeScene((ChipClusters.ScenesCluster.StoreSceneResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("sceneId") + + ); + }, + () -> new DelegatedStoreSceneResponseCallback(), + scenesstoreSceneCommandParams + ); + scenesClusterInteractionInfoMap.put("storeScene", scenesstoreSceneInteractionInfo); + Map scenesviewSceneCommandParams = new LinkedHashMap(); + CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); + scenesviewSceneCommandParams.put("groupId",scenesviewScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); + scenesviewSceneCommandParams.put("sceneId",scenesviewScenesceneIdCommandParameterInfo); + + InteractionInfo scenesviewSceneInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .viewScene((ChipClusters.ScenesCluster.ViewSceneResponseCallback) callback + , (Integer) + commandArguments.get("groupId") + , (Integer) + commandArguments.get("sceneId") + + ); + }, + () -> new DelegatedViewSceneResponseCallback(), + scenesviewSceneCommandParams + ); + scenesClusterInteractionInfoMap.put("viewScene", scenesviewSceneInteractionInfo); + commandMap.put("scenes", scenesClusterInteractionInfoMap); + Map softwareDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map softwareDiagnosticsresetWatermarksCommandParams = new LinkedHashMap(); + InteractionInfo softwareDiagnosticsresetWatermarksInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .resetWatermarks((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + softwareDiagnosticsresetWatermarksCommandParams + ); + softwareDiagnosticsClusterInteractionInfoMap.put("resetWatermarks", softwareDiagnosticsresetWatermarksInteractionInfo); + commandMap.put("softwareDiagnostics", softwareDiagnosticsClusterInteractionInfoMap); + Map switchClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("switch", switchClusterInteractionInfoMap); + Map targetNavigatorClusterInteractionInfoMap = new LinkedHashMap<>(); + Map targetNavigatornavigateTargetRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = new CommandParameterInfo("target", Integer.class); + targetNavigatornavigateTargetRequestCommandParams.put("target",targetNavigatornavigateTargetRequesttargetCommandParameterInfo); + + CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); + targetNavigatornavigateTargetRequestCommandParams.put("data",targetNavigatornavigateTargetRequestdataCommandParameterInfo); + + InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .navigateTargetRequest((ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback) callback + , (Integer) + commandArguments.get("target") + , (String) + commandArguments.get("data") + + ); + }, + () -> new DelegatedNavigateTargetResponseCallback(), + targetNavigatornavigateTargetRequestCommandParams + ); + targetNavigatorClusterInteractionInfoMap.put("navigateTargetRequest", targetNavigatornavigateTargetRequestInteractionInfo); + commandMap.put("targetNavigator", targetNavigatorClusterInteractionInfoMap); + Map temperatureMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); + Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); + Map testClustersimpleStructEchoRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustersimpleStructEchoRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .simpleStructEchoRequest((ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback + , (ChipStructs.TestClusterClusterSimpleStruct) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedSimpleStructResponseCallback(), + testClustersimpleStructEchoRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("simpleStructEchoRequest", testClustersimpleStructEchoRequestInteractionInfo); + Map testClustertestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .test((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestCommandParams + ); + testClusterClusterInteractionInfoMap.put("test", testClustertestInteractionInfo); + Map testClustertestAddArgumentsCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); + testClustertestAddArgumentsCommandParams.put("arg1",testClustertestAddArgumentsarg1CommandParameterInfo); + + CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); + testClustertestAddArgumentsCommandParams.put("arg2",testClustertestAddArgumentsarg2CommandParameterInfo); + + InteractionInfo testClustertestAddArgumentsInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testAddArguments((ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback) callback + , (Integer) + commandArguments.get("arg1") + , (Integer) + commandArguments.get("arg2") + + ); + }, + () -> new DelegatedTestAddArgumentsResponseCallback(), + testClustertestAddArgumentsCommandParams + ); + testClusterClusterInteractionInfoMap.put("testAddArguments", testClustertestAddArgumentsInteractionInfo); + Map testClustertestEmitTestEventRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); + testClustertestEmitTestEventRequestCommandParams.put("arg1",testClustertestEmitTestEventRequestarg1CommandParameterInfo); + + CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); + testClustertestEmitTestEventRequestCommandParams.put("arg2",testClustertestEmitTestEventRequestarg2CommandParameterInfo); + + CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = new CommandParameterInfo("arg3", Boolean.class); + testClustertestEmitTestEventRequestCommandParams.put("arg3",testClustertestEmitTestEventRequestarg3CommandParameterInfo); + + InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testEmitTestEventRequest((ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback) callback + , (Integer) + commandArguments.get("arg1") + , (Integer) + commandArguments.get("arg2") + , (Boolean) + commandArguments.get("arg3") + + ); + }, + () -> new DelegatedTestEmitTestEventResponseCallback(), + testClustertestEmitTestEventRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testEmitTestEventRequest", testClustertestEmitTestEventRequestInteractionInfo); + Map testClustertestEnumsRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); + testClustertestEnumsRequestCommandParams.put("arg1",testClustertestEnumsRequestarg1CommandParameterInfo); + + CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); + testClustertestEnumsRequestCommandParams.put("arg2",testClustertestEnumsRequestarg2CommandParameterInfo); + + InteractionInfo testClustertestEnumsRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testEnumsRequest((ChipClusters.TestClusterCluster.TestEnumsResponseCallback) callback + , (Integer) + commandArguments.get("arg1") + , (Integer) + commandArguments.get("arg2") + + ); + }, + () -> new DelegatedTestEnumsResponseCallback(), + testClustertestEnumsRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testEnumsRequest", testClustertestEnumsRequestInteractionInfo); + Map testClustertestListInt8UArgumentRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); + testClustertestListInt8UArgumentRequestCommandParams.put("arg1",testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListInt8UArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ArrayList) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListInt8UArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestInteractionInfo); + Map testClustertestListInt8UReverseRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); + testClustertestListInt8UReverseRequestCommandParams.put("arg1",testClustertestListInt8UReverseRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListInt8UReverseRequest((ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) callback + , (ArrayList) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedTestListInt8UReverseResponseCallback(), + testClustertestListInt8UReverseRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testListInt8UReverseRequest", testClustertestListInt8UReverseRequestInteractionInfo); + Map testClustertestListNestedStructListArgumentRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestListNestedStructListArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ArrayList) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListNestedStructListArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testListNestedStructListArgumentRequest", testClustertestListNestedStructListArgumentRequestInteractionInfo); + Map testClustertestListStructArgumentRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ArrayList) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListStructArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testListStructArgumentRequest", testClustertestListStructArgumentRequestInteractionInfo); + Map testClustertestNestedStructArgumentRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestNestedStructArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNestedStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ChipStructs.TestClusterClusterNestedStruct) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestNestedStructArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testNestedStructArgumentRequest", testClustertestNestedStructArgumentRequestInteractionInfo); + Map testClustertestNestedStructListArgumentRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestNestedStructListArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ChipStructs.TestClusterClusterNestedStructList) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestNestedStructListArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testNestedStructListArgumentRequest", testClustertestNestedStructListArgumentRequestInteractionInfo); + Map testClustertestNotHandledCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestNotHandledInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNotHandled((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestNotHandledCommandParams + ); + testClusterClusterInteractionInfoMap.put("testNotHandled", testClustertestNotHandledInteractionInfo); + Map testClustertestNullableOptionalRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); + testClustertestNullableOptionalRequestCommandParams.put("arg1",testClustertestNullableOptionalRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNullableOptionalRequest((ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) callback + , (Optional) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedTestNullableOptionalResponseCallback(), + testClustertestNullableOptionalRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testNullableOptionalRequest", testClustertestNullableOptionalRequestInteractionInfo); + Map testClustertestSimpleOptionalArgumentRequestCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); + testClustertestSimpleOptionalArgumentRequestCommandParams.put("arg1",testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testSimpleOptionalArgumentRequest((DefaultClusterCallback) callback + , (Optional) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestSimpleOptionalArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testSimpleOptionalArgumentRequest", testClustertestSimpleOptionalArgumentRequestInteractionInfo); + Map testClustertestSpecificCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestSpecificInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testSpecific((ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback + + ); + }, + () -> new DelegatedTestSpecificResponseCallback(), + testClustertestSpecificCommandParams + ); + testClusterClusterInteractionInfoMap.put("testSpecific", testClustertestSpecificInteractionInfo); + Map testClustertestStructArgumentRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestStructArgumentRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback + , (ChipStructs.TestClusterClusterSimpleStruct) + commandArguments.get("arg1") + + ); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestStructArgumentRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("testStructArgumentRequest", testClustertestStructArgumentRequestInteractionInfo); + Map testClustertestUnknownCommandCommandParams = new LinkedHashMap(); + InteractionInfo testClustertestUnknownCommandInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testUnknownCommand((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestUnknownCommandCommandParams + ); + testClusterClusterInteractionInfoMap.put("testUnknownCommand", testClustertestUnknownCommandInteractionInfo); + Map testClustertimedInvokeRequestCommandParams = new LinkedHashMap(); + InteractionInfo testClustertimedInvokeRequestInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .timedInvokeRequest((DefaultClusterCallback) callback + , 10000 + ); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertimedInvokeRequestCommandParams + ); + testClusterClusterInteractionInfoMap.put("timedInvokeRequest", testClustertimedInvokeRequestInteractionInfo); + commandMap.put("testCluster", testClusterClusterInteractionInfoMap); + Map thermostatClusterInteractionInfoMap = new LinkedHashMap<>(); + Map thermostatclearWeeklyScheduleCommandParams = new LinkedHashMap(); + InteractionInfo thermostatclearWeeklyScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .clearWeeklySchedule((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatclearWeeklyScheduleCommandParams + ); + thermostatClusterInteractionInfoMap.put("clearWeeklySchedule", thermostatclearWeeklyScheduleInteractionInfo); + Map thermostatgetRelayStatusLogCommandParams = new LinkedHashMap(); + InteractionInfo thermostatgetRelayStatusLogInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .getRelayStatusLog((ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback + + ); + }, + () -> new DelegatedGetRelayStatusLogResponseCallback(), + thermostatgetRelayStatusLogCommandParams + ); + thermostatClusterInteractionInfoMap.put("getRelayStatusLog", thermostatgetRelayStatusLogInteractionInfo); + Map thermostatgetWeeklyScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = new CommandParameterInfo("daysToReturn", Integer.class); + thermostatgetWeeklyScheduleCommandParams.put("daysToReturn",thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); + + CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = new CommandParameterInfo("modeToReturn", Integer.class); + thermostatgetWeeklyScheduleCommandParams.put("modeToReturn",thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); + + InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .getWeeklySchedule((ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback) callback + , (Integer) + commandArguments.get("daysToReturn") + , (Integer) + commandArguments.get("modeToReturn") + + ); + }, + () -> new DelegatedGetWeeklyScheduleResponseCallback(), + thermostatgetWeeklyScheduleCommandParams + ); + thermostatClusterInteractionInfoMap.put("getWeeklySchedule", thermostatgetWeeklyScheduleInteractionInfo); + Map thermostatsetWeeklyScheduleCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put("numberOfTransitionsForSequence",thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = new CommandParameterInfo("dayOfWeekForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put("dayOfWeekForSequence",thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = new CommandParameterInfo("modeForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put("modeForSequence",thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = new CommandParameterInfo("payload", ArrayList.class); + thermostatsetWeeklyScheduleCommandParams.put("payload",thermostatsetWeeklySchedulepayloadCommandParameterInfo); + + InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .setWeeklySchedule((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("numberOfTransitionsForSequence") + , (Integer) + commandArguments.get("dayOfWeekForSequence") + , (Integer) + commandArguments.get("modeForSequence") + , (ArrayList) + commandArguments.get("payload") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatsetWeeklyScheduleCommandParams + ); + thermostatClusterInteractionInfoMap.put("setWeeklySchedule", thermostatsetWeeklyScheduleInteractionInfo); + Map thermostatsetpointRaiseLowerCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = new CommandParameterInfo("mode", Integer.class); + thermostatsetpointRaiseLowerCommandParams.put("mode",thermostatsetpointRaiseLowermodeCommandParameterInfo); + + CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = new CommandParameterInfo("amount", Integer.class); + thermostatsetpointRaiseLowerCommandParams.put("amount",thermostatsetpointRaiseLoweramountCommandParameterInfo); + + InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .setpointRaiseLower((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("mode") + , (Integer) + commandArguments.get("amount") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatsetpointRaiseLowerCommandParams + ); + thermostatClusterInteractionInfoMap.put("setpointRaiseLower", thermostatsetpointRaiseLowerInteractionInfo); + commandMap.put("thermostat", thermostatClusterInteractionInfoMap); + Map thermostatUserInterfaceConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInteractionInfoMap); + Map threadNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map threadNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); + InteractionInfo threadNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + threadNetworkDiagnosticsresetCountsCommandParams + ); + threadNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", threadNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInteractionInfoMap); + Map timeFormatLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("timeFormatLocalization", timeFormatLocalizationClusterInteractionInfoMap); + Map unitLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("unitLocalization", unitLocalizationClusterInteractionInfoMap); + Map userLabelClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("userLabel", userLabelClusterInteractionInfoMap); + Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); + Map wiFiNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map wiFiNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); + InteractionInfo wiFiNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + wiFiNetworkDiagnosticsresetCountsCommandParams + ); + wiFiNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", wiFiNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInteractionInfoMap); + Map windowCoveringClusterInteractionInfoMap = new LinkedHashMap<>(); + Map windowCoveringdownOrCloseCommandParams = new LinkedHashMap(); + InteractionInfo windowCoveringdownOrCloseInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .downOrClose((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringdownOrCloseCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("downOrClose", windowCoveringdownOrCloseInteractionInfo); + Map windowCoveringgoToLiftPercentageCommandParams = new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = new CommandParameterInfo("liftPercentageValue", Integer.class); + windowCoveringgoToLiftPercentageCommandParams.put("liftPercentageValue",windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); + + CommandParameterInfo windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = new CommandParameterInfo("liftPercent100thsValue", Integer.class); + windowCoveringgoToLiftPercentageCommandParams.put("liftPercent100thsValue",windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToLiftPercentage((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("liftPercentageValue") + , (Integer) + commandArguments.get("liftPercent100thsValue") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToLiftPercentageCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("goToLiftPercentage", windowCoveringgoToLiftPercentageInteractionInfo); + Map windowCoveringgoToLiftValueCommandParams = new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = new CommandParameterInfo("liftValue", Integer.class); + windowCoveringgoToLiftValueCommandParams.put("liftValue",windowCoveringgoToLiftValueliftValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToLiftValueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToLiftValue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("liftValue") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToLiftValueCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("goToLiftValue", windowCoveringgoToLiftValueInteractionInfo); + Map windowCoveringgoToTiltPercentageCommandParams = new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = new CommandParameterInfo("tiltPercentageValue", Integer.class); + windowCoveringgoToTiltPercentageCommandParams.put("tiltPercentageValue",windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); + + CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = new CommandParameterInfo("tiltPercent100thsValue", Integer.class); + windowCoveringgoToTiltPercentageCommandParams.put("tiltPercent100thsValue",windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToTiltPercentage((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("tiltPercentageValue") + , (Integer) + commandArguments.get("tiltPercent100thsValue") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToTiltPercentageCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("goToTiltPercentage", windowCoveringgoToTiltPercentageInteractionInfo); + Map windowCoveringgoToTiltValueCommandParams = new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = new CommandParameterInfo("tiltValue", Integer.class); + windowCoveringgoToTiltValueCommandParams.put("tiltValue",windowCoveringgoToTiltValuetiltValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToTiltValueInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToTiltValue((DefaultClusterCallback) callback + , (Integer) + commandArguments.get("tiltValue") + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToTiltValueCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("goToTiltValue", windowCoveringgoToTiltValueInteractionInfo); + Map windowCoveringstopMotionCommandParams = new LinkedHashMap(); + InteractionInfo windowCoveringstopMotionInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .stopMotion((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringstopMotionCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("stopMotion", windowCoveringstopMotionInteractionInfo); + Map windowCoveringupOrOpenCommandParams = new LinkedHashMap(); + InteractionInfo windowCoveringupOrOpenInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .upOrOpen((DefaultClusterCallback) callback + + ); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringupOrOpenCommandParams + ); + windowCoveringClusterInteractionInfoMap.put("upOrOpen", windowCoveringupOrOpenInteractionInfo); + commandMap.put("windowCovering", windowCoveringClusterInteractionInfoMap); + return commandMap; } - public static class DelegatedBasicClusterAttributeListAttributeCallback - implements ChipClusters.BasicCluster.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 DelegatedBinaryInputBasicClusterAttributeListAttributeCallback - implements ChipClusters.BinaryInputBasicCluster.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 DelegatedBindingClusterAttributeListAttributeCallback - implements ChipClusters.BindingCluster.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 DelegatedBooleanStateClusterAttributeListAttributeCallback - implements ChipClusters.BooleanStateCluster.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 DelegatedBridgedActionsClusterActionListAttributeCallback - implements ChipClusters.BridgedActionsCluster.ActionListAttributeCallback, - 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 DelegatedBridgedActionsClusterEndpointListAttributeCallback - implements ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback, - 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 DelegatedBridgedActionsClusterAttributeListAttributeCallback - implements ChipClusters.BridgedActionsCluster.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 DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback - implements ChipClusters.BridgedDeviceBasicCluster.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 DelegatedChangeChannelResponseCallback - implements ChipClusters.ChannelCluster.ChangeChannelResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType) { - Map responseValues = new LinkedHashMap<>(); - // channelMatch: Struct ChannelInfo - // Conversion from this type to Java is not properly implemented yet - CommandResponseInfo errorTypeResponseValue = new CommandResponseInfo("errorType", "Integer"); - responseValues.put(errorTypeResponseValue, errorType); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedChannelClusterChannelListAttributeCallback - implements ChipClusters.ChannelCluster.ChannelListAttributeCallback, - 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 DelegatedChannelClusterAttributeListAttributeCallback - implements ChipClusters.ChannelCluster.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 DelegatedColorControlClusterAttributeListAttributeCallback - implements ChipClusters.ColorControlCluster.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 DelegatedLaunchResponseCallback - implements ChipClusters.ContentLauncherCluster.LaunchResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback - implements ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback, - 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 DelegatedContentLauncherClusterAttributeListAttributeCallback - implements ChipClusters.ContentLauncherCluster.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 DelegatedDescriptorClusterDeviceListAttributeCallback - implements ChipClusters.DescriptorCluster.DeviceListAttributeCallback, - 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 DelegatedDescriptorClusterServerListAttributeCallback - implements ChipClusters.DescriptorCluster.ServerListAttributeCallback, - 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 DelegatedDescriptorClusterClientListAttributeCallback - implements ChipClusters.DescriptorCluster.ClientListAttributeCallback, - 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 DelegatedDescriptorClusterPartsListAttributeCallback - implements ChipClusters.DescriptorCluster.PartsListAttributeCallback, - 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 DelegatedDescriptorClusterAttributeListAttributeCallback - implements ChipClusters.DescriptorCluster.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 DelegatedRetrieveLogsResponseCallback - implements ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo contentResponseValue = new CommandResponseInfo("content", "byte[]"); - responseValues.put(contentResponseValue, content); - CommandResponseInfo timeStampResponseValue = new CommandResponseInfo("timeStamp", "Long"); - responseValues.put(timeStampResponseValue, timeStamp); - CommandResponseInfo timeSinceBootResponseValue = - new CommandResponseInfo("timeSinceBoot", "Long"); - responseValues.put(timeSinceBootResponseValue, timeSinceBoot); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedDiagnosticLogsClusterAttributeListAttributeCallback - implements ChipClusters.DiagnosticLogsCluster.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 DelegatedGetCredentialStatusResponseCallback - implements ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Boolean credentialExists, - @Nullable Integer userIndex, - @Nullable Integer nextCredentialIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo credentialExistsResponseValue = - new CommandResponseInfo("credentialExists", "Boolean"); - responseValues.put(credentialExistsResponseValue, credentialExists); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo nextCredentialIndexResponseValue = - new CommandResponseInfo("nextCredentialIndex", "Integer"); - responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetUserResponseCallback - implements ChipClusters.DoorLockCluster.GetUserResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer userIndex, - @Nullable String userName, - @Nullable Long userUniqueId, - @Nullable Integer userStatus, - @Nullable Integer userType, - @Nullable Integer credentialRule, - @Nullable ArrayList credentials, - @Nullable Integer creatorFabricIndex, - @Nullable Integer lastModifiedFabricIndex, - @Nullable Integer nextUserIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo userNameResponseValue = new CommandResponseInfo("userName", "String"); - responseValues.put(userNameResponseValue, userName); - CommandResponseInfo userUniqueIdResponseValue = - new CommandResponseInfo("userUniqueId", "Long"); - responseValues.put(userUniqueIdResponseValue, userUniqueId); - CommandResponseInfo userStatusResponseValue = - new CommandResponseInfo("userStatus", "Integer"); - responseValues.put(userStatusResponseValue, userStatus); - CommandResponseInfo userTypeResponseValue = new CommandResponseInfo("userType", "Integer"); - responseValues.put(userTypeResponseValue, userType); - CommandResponseInfo credentialRuleResponseValue = - new CommandResponseInfo("credentialRule", "Integer"); - responseValues.put(credentialRuleResponseValue, credentialRule); - // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - CommandResponseInfo creatorFabricIndexResponseValue = - new CommandResponseInfo("creatorFabricIndex", "Integer"); - responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); - CommandResponseInfo lastModifiedFabricIndexResponseValue = - new CommandResponseInfo("lastModifiedFabricIndex", "Integer"); - responseValues.put(lastModifiedFabricIndexResponseValue, lastModifiedFabricIndex); - CommandResponseInfo nextUserIndexResponseValue = - new CommandResponseInfo("nextUserIndex", "Integer"); - responseValues.put(nextUserIndexResponseValue, nextUserIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetWeekDayScheduleResponseCallback - implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer weekDayIndex, - Integer userIndex, - Integer status, - Optional daysMask, - Optional startHour, - Optional startMinute, - Optional endHour, - Optional endMinute) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo weekDayIndexResponseValue = - new CommandResponseInfo("weekDayIndex", "Integer"); - responseValues.put(weekDayIndexResponseValue, weekDayIndex); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo daysMaskResponseValue = - new CommandResponseInfo("daysMask", "Optional"); - responseValues.put(daysMaskResponseValue, daysMask); - CommandResponseInfo startHourResponseValue = - new CommandResponseInfo("startHour", "Optional"); - responseValues.put(startHourResponseValue, startHour); - CommandResponseInfo startMinuteResponseValue = - new CommandResponseInfo("startMinute", "Optional"); - responseValues.put(startMinuteResponseValue, startMinute); - CommandResponseInfo endHourResponseValue = - new CommandResponseInfo("endHour", "Optional"); - responseValues.put(endHourResponseValue, endHour); - CommandResponseInfo endMinuteResponseValue = - new CommandResponseInfo("endMinute", "Optional"); - responseValues.put(endMinuteResponseValue, endMinute); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetYearDayScheduleResponseCallback - implements ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer yearDayIndex, - Integer userIndex, - Integer status, - Optional localStartTime, - Optional localEndTime) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo yearDayIndexResponseValue = - new CommandResponseInfo("yearDayIndex", "Integer"); - responseValues.put(yearDayIndexResponseValue, yearDayIndex); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo localStartTimeResponseValue = - new CommandResponseInfo("localStartTime", "Optional"); - responseValues.put(localStartTimeResponseValue, localStartTime); - CommandResponseInfo localEndTimeResponseValue = - new CommandResponseInfo("localEndTime", "Optional"); - responseValues.put(localEndTimeResponseValue, localEndTime); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSetCredentialResponseCallback - implements ChipClusters.DoorLockCluster.SetCredentialResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo nextCredentialIndexResponseValue = - new CommandResponseInfo("nextCredentialIndex", "Integer"); - responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedDoorLockClusterAttributeListAttributeCallback - implements ChipClusters.DoorLockCluster.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 DelegatedElectricalMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.ElectricalMeasurementCluster.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 DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback - implements ChipClusters.EthernetNetworkDiagnosticsCluster.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 DelegatedFixedLabelClusterLabelListAttributeCallback - implements ChipClusters.FixedLabelCluster.LabelListAttributeCallback, - 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 DelegatedFixedLabelClusterAttributeListAttributeCallback - implements ChipClusters.FixedLabelCluster.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 DelegatedFlowMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.FlowMeasurementCluster.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 DelegatedArmFailSafeResponseCallback - implements ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedCommissioningCompleteResponseCallback - implements ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSetRegulatoryConfigResponseCallback - implements ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static - class DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback - implements ChipClusters.GeneralCommissioningCluster - .BasicCommissioningInfoListAttributeCallback, - 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 DelegatedGeneralCommissioningClusterAttributeListAttributeCallback - implements ChipClusters.GeneralCommissioningCluster.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 DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback - implements ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback, - 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 DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback - implements ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback, - 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 DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback - implements ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback, - 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 DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback - implements ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback, - 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 DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback - implements ChipClusters.GeneralDiagnosticsCluster.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 DelegatedKeySetReadAllIndicesResponseCallback - implements ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ArrayList groupKeySetIDs) { - Map responseValues = new LinkedHashMap<>(); - // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedKeySetReadResponseCallback - implements ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { - Map responseValues = new LinkedHashMap<>(); - // groupKeySet: Struct GroupKeySet - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback - implements ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback, - 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 DelegatedGroupKeyManagementClusterGroupTableAttributeCallback - implements ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback, - 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 DelegatedGroupKeyManagementClusterAttributeListAttributeCallback - implements ChipClusters.GroupKeyManagementCluster.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 DelegatedAddGroupResponseCallback - implements ChipClusters.GroupsCluster.AddGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetGroupMembershipResponseCallback - implements ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer capacity, ArrayList groupList) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); - responseValues.put(capacityResponseValue, capacity); - // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveGroupResponseCallback - implements ChipClusters.GroupsCluster.RemoveGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedViewGroupResponseCallback - implements ChipClusters.GroupsCluster.ViewGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, String groupName) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo groupNameResponseValue = new CommandResponseInfo("groupName", "String"); - responseValues.put(groupNameResponseValue, groupName); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGroupsClusterAttributeListAttributeCallback - implements ChipClusters.GroupsCluster.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 DelegatedIdentifyQueryResponseCallback - implements ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer timeout) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo timeoutResponseValue = new CommandResponseInfo("timeout", "Integer"); - responseValues.put(timeoutResponseValue, timeout); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedIdentifyClusterAttributeListAttributeCallback - implements ChipClusters.IdentifyCluster.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 DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.IlluminanceMeasurementCluster.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 DelegatedSendKeyResponseCallback - implements ChipClusters.KeypadInputCluster.SendKeyResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedKeypadInputClusterAttributeListAttributeCallback - implements ChipClusters.KeypadInputCluster.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 DelegatedLevelControlClusterAttributeListAttributeCallback - implements ChipClusters.LevelControlCluster.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 DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback - implements ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback, - 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 DelegatedLowPowerClusterAttributeListAttributeCallback - implements ChipClusters.LowPowerCluster.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 DelegatedMediaInputClusterMediaInputListAttributeCallback - implements ChipClusters.MediaInputCluster.MediaInputListAttributeCallback, - 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 DelegatedMediaInputClusterAttributeListAttributeCallback - implements ChipClusters.MediaInputCluster.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 DelegatedPlaybackResponseCallback - implements ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedMediaPlaybackClusterAttributeListAttributeCallback - implements ChipClusters.MediaPlaybackCluster.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 DelegatedModeSelectClusterSupportedModesAttributeCallback - implements ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback, - 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 DelegatedModeSelectClusterAttributeListAttributeCallback - implements ChipClusters.ModeSelectCluster.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 DelegatedConnectNetworkResponseCallback - implements ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText, Long ErrorValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = - new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - CommandResponseInfo ErrorValueResponseValue = new CommandResponseInfo("ErrorValue", "Long"); - responseValues.put(ErrorValueResponseValue, ErrorValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNetworkConfigResponseCallback - implements ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = - new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedScanNetworksResponseCallback - implements ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer NetworkingStatus, - String DebugText, - Optional> - WiFiScanResults, - Optional> - ThreadScanResults) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = - new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - // WiFiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - // ThreadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNetworkCommissioningClusterNetworksAttributeCallback - implements ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback, - 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 DelegatedApplyUpdateResponseCallback - implements ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer action, Long delayedActionTime) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo actionResponseValue = new CommandResponseInfo("action", "Integer"); - responseValues.put(actionResponseValue, action); - CommandResponseInfo delayedActionTimeResponseValue = - new CommandResponseInfo("delayedActionTime", "Long"); - responseValues.put(delayedActionTimeResponseValue, delayedActionTime); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedQueryImageResponseCallback - implements ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer status, - Optional delayedActionTime, - Optional imageURI, - Optional softwareVersion, - Optional softwareVersionString, - Optional updateToken, - Optional userConsentNeeded, - Optional metadataForRequestor) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo delayedActionTimeResponseValue = - new CommandResponseInfo("delayedActionTime", "Optional"); - responseValues.put(delayedActionTimeResponseValue, delayedActionTime); - CommandResponseInfo imageURIResponseValue = - new CommandResponseInfo("imageURI", "Optional"); - responseValues.put(imageURIResponseValue, imageURI); - CommandResponseInfo softwareVersionResponseValue = - new CommandResponseInfo("softwareVersion", "Optional"); - responseValues.put(softwareVersionResponseValue, softwareVersion); - CommandResponseInfo softwareVersionStringResponseValue = - new CommandResponseInfo("softwareVersionString", "Optional"); - responseValues.put(softwareVersionStringResponseValue, softwareVersionString); - CommandResponseInfo updateTokenResponseValue = - new CommandResponseInfo("updateToken", "Optional"); - responseValues.put(updateTokenResponseValue, updateToken); - CommandResponseInfo userConsentNeededResponseValue = - new CommandResponseInfo("userConsentNeeded", "Optional"); - responseValues.put(userConsentNeededResponseValue, userConsentNeeded); - CommandResponseInfo metadataForRequestorResponseValue = - new CommandResponseInfo("metadataForRequestor", "Optional"); - responseValues.put(metadataForRequestorResponseValue, metadataForRequestor); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback - implements ChipClusters.OtaSoftwareUpdateProviderCluster.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 DelegatedOtaSoftwareUpdateRequestorClusterDefaultOtaProvidersAttributeCallback - implements ChipClusters.OtaSoftwareUpdateRequestorCluster - .DefaultOtaProvidersAttributeCallback, - 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 DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback - implements ChipClusters.OtaSoftwareUpdateRequestorCluster.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 DelegatedOccupancySensingClusterAttributeListAttributeCallback - implements ChipClusters.OccupancySensingCluster.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 DelegatedOnOffClusterAttributeListAttributeCallback - implements ChipClusters.OnOffCluster.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 DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback - implements ChipClusters.OnOffSwitchConfigurationCluster.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 DelegatedAttestationResponseCallback - implements ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] AttestationElements, byte[] Signature) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo AttestationElementsResponseValue = - new CommandResponseInfo("AttestationElements", "byte[]"); - responseValues.put(AttestationElementsResponseValue, AttestationElements); - CommandResponseInfo SignatureResponseValue = new CommandResponseInfo("Signature", "byte[]"); - responseValues.put(SignatureResponseValue, Signature); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedCertificateChainResponseCallback - implements ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] Certificate) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo CertificateResponseValue = - new CommandResponseInfo("Certificate", "byte[]"); - responseValues.put(CertificateResponseValue, Certificate); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNOCResponseCallback - implements ChipClusters.OperationalCredentialsCluster.NOCResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer StatusCode, Integer FabricIndex, String DebugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo StatusCodeResponseValue = - new CommandResponseInfo("StatusCode", "Integer"); - responseValues.put(StatusCodeResponseValue, StatusCode); - CommandResponseInfo FabricIndexResponseValue = - new CommandResponseInfo("FabricIndex", "Integer"); - responseValues.put(FabricIndexResponseValue, FabricIndex); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedOpCSRResponseCallback - implements ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] NOCSRElements, byte[] AttestationSignature) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NOCSRElementsResponseValue = - new CommandResponseInfo("NOCSRElements", "byte[]"); - responseValues.put(NOCSRElementsResponseValue, NOCSRElements); - CommandResponseInfo AttestationSignatureResponseValue = - new CommandResponseInfo("AttestationSignature", "byte[]"); - responseValues.put(AttestationSignatureResponseValue, AttestationSignature); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedOperationalCredentialsClusterNOCsAttributeCallback - implements ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback, - 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 DelegatedOperationalCredentialsClusterFabricsListAttributeCallback - implements ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback, - 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 DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback - implements ChipClusters.OperationalCredentialsCluster - .TrustedRootCertificatesAttributeCallback, - 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 DelegatedOperationalCredentialsClusterAttributeListAttributeCallback - implements ChipClusters.OperationalCredentialsCluster.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 DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback - implements ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback, - 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 DelegatedPowerSourceClusterAttributeListAttributeCallback - implements ChipClusters.PowerSourceCluster.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 DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback - implements ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback, - 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 DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback - implements ChipClusters.PowerSourceConfigurationCluster.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 DelegatedPressureMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.PressureMeasurementCluster.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 DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback - implements ChipClusters.PumpConfigurationAndControlCluster.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 DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.RelativeHumidityMeasurementCluster.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 DelegatedAddSceneResponseCallback - implements ChipClusters.ScenesCluster.AddSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetSceneMembershipResponseCallback - implements ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer status, - Integer capacity, - Integer groupId, - Integer sceneCount, - ArrayList sceneList) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); - responseValues.put(capacityResponseValue, capacity); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneCountResponseValue = - new CommandResponseInfo("sceneCount", "Integer"); - responseValues.put(sceneCountResponseValue, sceneCount); - // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveAllScenesResponseCallback - implements ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveSceneResponseCallback - implements ChipClusters.ScenesCluster.RemoveSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedStoreSceneResponseCallback - implements ChipClusters.ScenesCluster.StoreSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedViewSceneResponseCallback - implements ChipClusters.ScenesCluster.ViewSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer status, - Integer groupId, - Integer sceneId, - Integer transitionTime, - String sceneName, - ArrayList extensionFieldSets) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - CommandResponseInfo transitionTimeResponseValue = - new CommandResponseInfo("transitionTime", "Integer"); - responseValues.put(transitionTimeResponseValue, transitionTime); - CommandResponseInfo sceneNameResponseValue = new CommandResponseInfo("sceneName", "String"); - responseValues.put(sceneNameResponseValue, sceneName); - // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedScenesClusterAttributeListAttributeCallback - implements ChipClusters.ScenesCluster.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 DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback - implements ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback, - 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 DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback - implements ChipClusters.SoftwareDiagnosticsCluster.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 DelegatedSwitchClusterAttributeListAttributeCallback - implements ChipClusters.SwitchCluster.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 DelegatedNavigateTargetResponseCallback - implements ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback - implements ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback, - 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 DelegatedTargetNavigatorClusterAttributeListAttributeCallback - implements ChipClusters.TargetNavigatorCluster.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 DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback - implements ChipClusters.TemperatureMeasurementCluster.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 DelegatedBooleanResponseCallback - implements ChipClusters.TestClusterCluster.BooleanResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Boolean value) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Boolean"); - responseValues.put(valueResponseValue, value); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSimpleStructResponseCallback - implements ChipClusters.TestClusterCluster.SimpleStructResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1) { - Map responseValues = new LinkedHashMap<>(); - // arg1: Struct SimpleStruct - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestAddArgumentsResponseCallback - implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer returnValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo returnValueResponseValue = - new CommandResponseInfo("returnValue", "Integer"); - responseValues.put(returnValueResponseValue, returnValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestEmitTestEventResponseCallback - implements ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Long value) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Long"); - responseValues.put(valueResponseValue, value); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestEnumsResponseCallback - implements ChipClusters.TestClusterCluster.TestEnumsResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer arg1, Integer arg2) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo arg1ResponseValue = new CommandResponseInfo("arg1", "Integer"); - responseValues.put(arg1ResponseValue, arg1); - CommandResponseInfo arg2ResponseValue = new CommandResponseInfo("arg2", "Integer"); - responseValues.put(arg2ResponseValue, arg2); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestListInt8UReverseResponseCallback - implements ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ArrayList arg1) { - Map responseValues = new LinkedHashMap<>(); - // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestNullableOptionalResponseCallback - implements ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Boolean wasPresent, - Optional wasNull, - Optional value, - @Nullable Optional originalValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo wasPresentResponseValue = - new CommandResponseInfo("wasPresent", "Boolean"); - responseValues.put(wasPresentResponseValue, wasPresent); - CommandResponseInfo wasNullResponseValue = - new CommandResponseInfo("wasNull", "Optional"); - responseValues.put(wasNullResponseValue, wasNull); - CommandResponseInfo valueResponseValue = - new CommandResponseInfo("value", "Optional"); - responseValues.put(valueResponseValue, value); - CommandResponseInfo originalValueResponseValue = - new CommandResponseInfo("originalValue", "Optional"); - responseValues.put(originalValueResponseValue, originalValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestSpecificResponseCallback - implements ChipClusters.TestClusterCluster.TestSpecificResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer returnValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo returnValueResponseValue = - new CommandResponseInfo("returnValue", "Integer"); - responseValues.put(returnValueResponseValue, returnValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestClusterClusterListInt8uAttributeCallback - implements ChipClusters.TestClusterCluster.ListInt8uAttributeCallback, - 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 DelegatedTestClusterClusterListOctetStringAttributeCallback - implements ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback, - 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 DelegatedTestClusterClusterListStructOctetStringAttributeCallback - implements ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback, - 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 DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback - implements ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback, - 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 DelegatedTestClusterClusterListLongOctetStringAttributeCallback - implements ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback, - 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 DelegatedTestClusterClusterAttributeListAttributeCallback - implements ChipClusters.TestClusterCluster.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 DelegatedGetRelayStatusLogResponseCallback - implements ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer timeOfDay, - Integer relayStatus, - Integer localTemperature, - Integer humidityInPercentage, - Integer setpoint, - Integer unreadEntries) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo timeOfDayResponseValue = new CommandResponseInfo("timeOfDay", "Integer"); - responseValues.put(timeOfDayResponseValue, timeOfDay); - CommandResponseInfo relayStatusResponseValue = - new CommandResponseInfo("relayStatus", "Integer"); - responseValues.put(relayStatusResponseValue, relayStatus); - CommandResponseInfo localTemperatureResponseValue = - new CommandResponseInfo("localTemperature", "Integer"); - responseValues.put(localTemperatureResponseValue, localTemperature); - CommandResponseInfo humidityInPercentageResponseValue = - new CommandResponseInfo("humidityInPercentage", "Integer"); - responseValues.put(humidityInPercentageResponseValue, humidityInPercentage); - CommandResponseInfo setpointResponseValue = new CommandResponseInfo("setpoint", "Integer"); - responseValues.put(setpointResponseValue, setpoint); - CommandResponseInfo unreadEntriesResponseValue = - new CommandResponseInfo("unreadEntries", "Integer"); - responseValues.put(unreadEntriesResponseValue, unreadEntries); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetWeeklyScheduleResponseCallback - implements ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback, - DelegatedClusterCallback { - private ClusterCommandCallback callback; - - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess( - Integer numberOfTransitionsForSequence, - Integer dayOfWeekForSequence, - Integer modeForSequence, - ArrayList payload) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo numberOfTransitionsForSequenceResponseValue = - new CommandResponseInfo("numberOfTransitionsForSequence", "Integer"); - responseValues.put( - numberOfTransitionsForSequenceResponseValue, numberOfTransitionsForSequence); - CommandResponseInfo dayOfWeekForSequenceResponseValue = - new CommandResponseInfo("dayOfWeekForSequence", "Integer"); - responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); - CommandResponseInfo modeForSequenceResponseValue = - new CommandResponseInfo("modeForSequence", "Integer"); - responseValues.put(modeForSequenceResponseValue, modeForSequence); - // payload: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedThermostatClusterAttributeListAttributeCallback - implements ChipClusters.ThermostatCluster.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 DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback - implements ChipClusters.ThermostatUserInterfaceConfigurationCluster - .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 DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback, - 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 DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback, - 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 DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback, - 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 DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster - .OperationalDatasetComponentsAttributeCallback, - 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 DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster - .ActiveNetworkFaultsListAttributeCallback, - 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 DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback - implements ChipClusters.ThreadNetworkDiagnosticsCluster.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 DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback - implements ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback, - 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 DelegatedUserLabelClusterLabelListAttributeCallback - implements ChipClusters.UserLabelCluster.LabelListAttributeCallback, - 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 DelegatedWakeOnLanClusterAttributeListAttributeCallback - implements ChipClusters.WakeOnLanCluster.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 DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback - implements ChipClusters.WiFiNetworkDiagnosticsCluster.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 DelegatedWindowCoveringClusterAttributeListAttributeCallback - implements ChipClusters.WindowCoveringCluster.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 Map getClusterMap() { - Map clusterMap = initializeClusterMap(); - Map> commandMap = getCommandMap(); - combineCommand(clusterMap, commandMap); - Map> readAttributeMap = - new ClusterReadMapping().getReadAttributeMap(); - combineCommand(clusterMap, readAttributeMap); - Map> writeAttributeMap = - new ClusterWriteMapping().getWriteAttributeMap(); - combineCommand(clusterMap, writeAttributeMap); - return clusterMap; - } - - public Map initializeClusterMap() { - Map clusterMap = new HashMap<>(); - ClusterInfo accessControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AccessControlCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("accessControl", accessControlClusterInfo); - ClusterInfo accountLoginClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("accountLogin", accountLoginClusterInfo); - ClusterInfo administratorCommissioningClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); - ClusterInfo applicationBasicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("applicationBasic", applicationBasicClusterInfo); - ClusterInfo applicationLauncherClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); - ClusterInfo audioOutputClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("audioOutput", audioOutputClusterInfo); - ClusterInfo barrierControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("barrierControl", barrierControlClusterInfo); - ClusterInfo basicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("basic", basicClusterInfo); - ClusterInfo binaryInputBasicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); - ClusterInfo bindingClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("binding", bindingClusterInfo); - ClusterInfo booleanStateClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("booleanState", booleanStateClusterInfo); - ClusterInfo bridgedActionsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("bridgedActions", bridgedActionsClusterInfo); - ClusterInfo bridgedDeviceBasicClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); - ClusterInfo channelClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ChannelCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("channel", channelClusterInfo); - ClusterInfo colorControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("colorControl", colorControlClusterInfo); - ClusterInfo contentLauncherClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("contentLauncher", contentLauncherClusterInfo); - ClusterInfo descriptorClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("descriptor", descriptorClusterInfo); - ClusterInfo diagnosticLogsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); - ClusterInfo doorLockClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("doorLock", doorLockClusterInfo); - ClusterInfo electricalMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); - ClusterInfo ethernetNetworkDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); - ClusterInfo fixedLabelClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("fixedLabel", fixedLabelClusterInfo); - ClusterInfo flowMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); - ClusterInfo generalCommissioningClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); - ClusterInfo generalDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); - ClusterInfo groupKeyManagementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); - ClusterInfo groupsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("groups", groupsClusterInfo); - ClusterInfo identifyClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("identify", identifyClusterInfo); - ClusterInfo illuminanceMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); - ClusterInfo keypadInputClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("keypadInput", keypadInputClusterInfo); - ClusterInfo levelControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("levelControl", levelControlClusterInfo); - ClusterInfo localizationConfigurationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LocalizationConfigurationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("localizationConfiguration", localizationConfigurationClusterInfo); - ClusterInfo lowPowerClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("lowPower", lowPowerClusterInfo); - ClusterInfo mediaInputClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("mediaInput", mediaInputClusterInfo); - ClusterInfo mediaPlaybackClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); - ClusterInfo modeSelectClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("modeSelect", modeSelectClusterInfo); - ClusterInfo networkCommissioningClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); - ClusterInfo otaSoftwareUpdateProviderClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); - ClusterInfo otaSoftwareUpdateRequestorClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); - ClusterInfo occupancySensingClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("occupancySensing", occupancySensingClusterInfo); - ClusterInfo onOffClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("onOff", onOffClusterInfo); - ClusterInfo onOffSwitchConfigurationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); - ClusterInfo operationalCredentialsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); - ClusterInfo powerSourceClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("powerSource", powerSourceClusterInfo); - ClusterInfo powerSourceConfigurationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PowerSourceConfigurationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInfo); - ClusterInfo pressureMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); - ClusterInfo pumpConfigurationAndControlClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); - ClusterInfo relativeHumidityMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); - ClusterInfo scenesClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("scenes", scenesClusterInfo); - ClusterInfo softwareDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); - ClusterInfo switchClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("switch", switchClusterInfo); - ClusterInfo targetNavigatorClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("targetNavigator", targetNavigatorClusterInfo); - ClusterInfo temperatureMeasurementClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); - ClusterInfo testClusterClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("testCluster", testClusterClusterInfo); - ClusterInfo thermostatClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("thermostat", thermostatClusterInfo); - ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> - new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put( - "thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); - ClusterInfo threadNetworkDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); - ClusterInfo timeFormatLocalizationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TimeFormatLocalizationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("timeFormatLocalization", timeFormatLocalizationClusterInfo); - ClusterInfo unitLocalizationClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.UnitLocalizationCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("unitLocalization", unitLocalizationClusterInfo); - ClusterInfo userLabelClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.UserLabelCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("userLabel", userLabelClusterInfo); - ClusterInfo wakeOnLanClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); - ClusterInfo wiFiNetworkDiagnosticsClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); - ClusterInfo windowCoveringClusterInfo = - new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), - new HashMap<>()); - clusterMap.put("windowCovering", windowCoveringClusterInfo); - return clusterMap; - } - - public void combineCommand( - Map destination, Map> source) { - destination.get("accessControl").combineCommands(source.get("accessControl")); - destination.get("accountLogin").combineCommands(source.get("accountLogin")); - destination - .get("administratorCommissioning") - .combineCommands(source.get("administratorCommissioning")); - destination.get("applicationBasic").combineCommands(source.get("applicationBasic")); - destination.get("applicationLauncher").combineCommands(source.get("applicationLauncher")); - destination.get("audioOutput").combineCommands(source.get("audioOutput")); - destination.get("barrierControl").combineCommands(source.get("barrierControl")); - destination.get("basic").combineCommands(source.get("basic")); - destination.get("binaryInputBasic").combineCommands(source.get("binaryInputBasic")); - destination.get("binding").combineCommands(source.get("binding")); - destination.get("booleanState").combineCommands(source.get("booleanState")); - destination.get("bridgedActions").combineCommands(source.get("bridgedActions")); - destination.get("bridgedDeviceBasic").combineCommands(source.get("bridgedDeviceBasic")); - destination.get("channel").combineCommands(source.get("channel")); - destination.get("colorControl").combineCommands(source.get("colorControl")); - destination.get("contentLauncher").combineCommands(source.get("contentLauncher")); - destination.get("descriptor").combineCommands(source.get("descriptor")); - destination.get("diagnosticLogs").combineCommands(source.get("diagnosticLogs")); - destination.get("doorLock").combineCommands(source.get("doorLock")); - destination.get("electricalMeasurement").combineCommands(source.get("electricalMeasurement")); - destination - .get("ethernetNetworkDiagnostics") - .combineCommands(source.get("ethernetNetworkDiagnostics")); - destination.get("fixedLabel").combineCommands(source.get("fixedLabel")); - destination.get("flowMeasurement").combineCommands(source.get("flowMeasurement")); - destination.get("generalCommissioning").combineCommands(source.get("generalCommissioning")); - destination.get("generalDiagnostics").combineCommands(source.get("generalDiagnostics")); - destination.get("groupKeyManagement").combineCommands(source.get("groupKeyManagement")); - destination.get("groups").combineCommands(source.get("groups")); - destination.get("identify").combineCommands(source.get("identify")); - destination.get("illuminanceMeasurement").combineCommands(source.get("illuminanceMeasurement")); - destination.get("keypadInput").combineCommands(source.get("keypadInput")); - destination.get("levelControl").combineCommands(source.get("levelControl")); - destination - .get("localizationConfiguration") - .combineCommands(source.get("localizationConfiguration")); - destination.get("lowPower").combineCommands(source.get("lowPower")); - destination.get("mediaInput").combineCommands(source.get("mediaInput")); - destination.get("mediaPlayback").combineCommands(source.get("mediaPlayback")); - destination.get("modeSelect").combineCommands(source.get("modeSelect")); - destination.get("networkCommissioning").combineCommands(source.get("networkCommissioning")); - destination - .get("otaSoftwareUpdateProvider") - .combineCommands(source.get("otaSoftwareUpdateProvider")); - destination - .get("otaSoftwareUpdateRequestor") - .combineCommands(source.get("otaSoftwareUpdateRequestor")); - destination.get("occupancySensing").combineCommands(source.get("occupancySensing")); - destination.get("onOff").combineCommands(source.get("onOff")); - destination - .get("onOffSwitchConfiguration") - .combineCommands(source.get("onOffSwitchConfiguration")); - destination.get("operationalCredentials").combineCommands(source.get("operationalCredentials")); - destination.get("powerSource").combineCommands(source.get("powerSource")); - destination - .get("powerSourceConfiguration") - .combineCommands(source.get("powerSourceConfiguration")); - destination.get("pressureMeasurement").combineCommands(source.get("pressureMeasurement")); - destination - .get("pumpConfigurationAndControl") - .combineCommands(source.get("pumpConfigurationAndControl")); - destination - .get("relativeHumidityMeasurement") - .combineCommands(source.get("relativeHumidityMeasurement")); - destination.get("scenes").combineCommands(source.get("scenes")); - destination.get("softwareDiagnostics").combineCommands(source.get("softwareDiagnostics")); - destination.get("switch").combineCommands(source.get("switch")); - destination.get("targetNavigator").combineCommands(source.get("targetNavigator")); - destination.get("temperatureMeasurement").combineCommands(source.get("temperatureMeasurement")); - destination.get("testCluster").combineCommands(source.get("testCluster")); - destination.get("thermostat").combineCommands(source.get("thermostat")); - destination - .get("thermostatUserInterfaceConfiguration") - .combineCommands(source.get("thermostatUserInterfaceConfiguration")); - destination - .get("threadNetworkDiagnostics") - .combineCommands(source.get("threadNetworkDiagnostics")); - destination.get("timeFormatLocalization").combineCommands(source.get("timeFormatLocalization")); - destination.get("unitLocalization").combineCommands(source.get("unitLocalization")); - destination.get("userLabel").combineCommands(source.get("userLabel")); - destination.get("wakeOnLan").combineCommands(source.get("wakeOnLan")); - destination.get("wiFiNetworkDiagnostics").combineCommands(source.get("wiFiNetworkDiagnostics")); - destination.get("windowCovering").combineCommands(source.get("windowCovering")); - } - - @SuppressWarnings("unchecked") - public Map> getCommandMap() { - Map> commandMap = new HashMap<>(); - Map accessControlClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("accessControl", accessControlClusterInteractionInfoMap); - Map accountLoginClusterInteractionInfoMap = new LinkedHashMap<>(); - Map accountLogingetSetupPINRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = - new CommandParameterInfo("tempAccountIdentifier", String.class); - accountLogingetSetupPINRequestCommandParams.put( - "tempAccountIdentifier", - accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); - - InteractionInfo accountLogingetSetupPINRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .getSetupPINRequest( - (ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback) callback, - (String) commandArguments.get("tempAccountIdentifier"), - 10000); - }, - () -> new DelegatedGetSetupPINResponseCallback(), - accountLogingetSetupPINRequestCommandParams); - accountLoginClusterInteractionInfoMap.put( - "getSetupPINRequest", accountLogingetSetupPINRequestInteractionInfo); - Map accountLoginloginRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = - new CommandParameterInfo("tempAccountIdentifier", String.class); - accountLoginloginRequestCommandParams.put( - "tempAccountIdentifier", accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); - - CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = - new CommandParameterInfo("setupPIN", String.class); - accountLoginloginRequestCommandParams.put( - "setupPIN", accountLoginloginRequestsetupPINCommandParameterInfo); - - InteractionInfo accountLoginloginRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .loginRequest( - (DefaultClusterCallback) callback, - (String) commandArguments.get("tempAccountIdentifier"), - (String) commandArguments.get("setupPIN"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - accountLoginloginRequestCommandParams); - accountLoginClusterInteractionInfoMap.put( - "loginRequest", accountLoginloginRequestInteractionInfo); - Map accountLoginlogoutRequestCommandParams = - new LinkedHashMap(); - InteractionInfo accountLoginlogoutRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .logoutRequest((DefaultClusterCallback) callback, 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - accountLoginlogoutRequestCommandParams); - accountLoginClusterInteractionInfoMap.put( - "logoutRequest", accountLoginlogoutRequestInteractionInfo); - commandMap.put("accountLogin", accountLoginClusterInteractionInfoMap); - Map administratorCommissioningClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map - administratorCommissioningopenBasicCommissioningWindowCommandParams = - new LinkedHashMap(); - CommandParameterInfo - administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = - new CommandParameterInfo("commissioningTimeout", Integer.class); - administratorCommissioningopenBasicCommissioningWindowCommandParams.put( - "commissioningTimeout", - administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); - - InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .openBasicCommissioningWindow( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("commissioningTimeout"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningopenBasicCommissioningWindowCommandParams); - administratorCommissioningClusterInteractionInfoMap.put( - "openBasicCommissioningWindow", - administratorCommissioningopenBasicCommissioningWindowInteractionInfo); - Map - administratorCommissioningopenCommissioningWindowCommandParams = - new LinkedHashMap(); - CommandParameterInfo - administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = - new CommandParameterInfo("commissioningTimeout", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "commissioningTimeout", - administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); - - CommandParameterInfo - administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = - new CommandParameterInfo("PAKEVerifier", byte[].class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "PAKEVerifier", - administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); - - CommandParameterInfo - administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = - new CommandParameterInfo("discriminator", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "discriminator", - administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); - - CommandParameterInfo - administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = - new CommandParameterInfo("iterations", Long.class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "iterations", - administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = - new CommandParameterInfo("salt", byte[].class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "salt", administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); - - CommandParameterInfo - administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = - new CommandParameterInfo("passcodeID", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put( - "passcodeID", - administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); - - InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .openCommissioningWindow( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("commissioningTimeout"), - (byte[]) commandArguments.get("PAKEVerifier"), - (Integer) commandArguments.get("discriminator"), - (Long) commandArguments.get("iterations"), - (byte[]) commandArguments.get("salt"), - (Integer) commandArguments.get("passcodeID"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningopenCommissioningWindowCommandParams); - administratorCommissioningClusterInteractionInfoMap.put( - "openCommissioningWindow", - administratorCommissioningopenCommissioningWindowInteractionInfo); - Map administratorCommissioningrevokeCommissioningCommandParams = - new LinkedHashMap(); - InteractionInfo administratorCommissioningrevokeCommissioningInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .revokeCommissioning((DefaultClusterCallback) callback, 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningrevokeCommissioningCommandParams); - administratorCommissioningClusterInteractionInfoMap.put( - "revokeCommissioning", administratorCommissioningrevokeCommissioningInteractionInfo); - commandMap.put( - "administratorCommissioning", administratorCommissioningClusterInteractionInfoMap); - Map applicationBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("applicationBasic", applicationBasicClusterInteractionInfoMap); - Map applicationLauncherClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map applicationLauncherhideAppRequestCommandParams = - new LinkedHashMap(); - InteractionInfo applicationLauncherhideAppRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .hideAppRequest( - (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, - (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application")); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherhideAppRequestCommandParams); - applicationLauncherClusterInteractionInfoMap.put( - "hideAppRequest", applicationLauncherhideAppRequestInteractionInfo); - Map applicationLauncherlaunchAppRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = - new CommandParameterInfo("data", String.class); - applicationLauncherlaunchAppRequestCommandParams.put( - "data", applicationLauncherlaunchAppRequestdataCommandParameterInfo); - - InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .launchAppRequest( - (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, - (String) commandArguments.get("data"), - (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application")); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherlaunchAppRequestCommandParams); - applicationLauncherClusterInteractionInfoMap.put( - "launchAppRequest", applicationLauncherlaunchAppRequestInteractionInfo); - Map applicationLauncherstopAppRequestCommandParams = - new LinkedHashMap(); - InteractionInfo applicationLauncherstopAppRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .stopAppRequest( - (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, - (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application")); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherstopAppRequestCommandParams); - applicationLauncherClusterInteractionInfoMap.put( - "stopAppRequest", applicationLauncherstopAppRequestInteractionInfo); - commandMap.put("applicationLauncher", applicationLauncherClusterInteractionInfoMap); - Map audioOutputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map audioOutputrenameOutputRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = - new CommandParameterInfo("index", Integer.class); - audioOutputrenameOutputRequestCommandParams.put( - "index", audioOutputrenameOutputRequestindexCommandParameterInfo); - - CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = - new CommandParameterInfo("name", String.class); - audioOutputrenameOutputRequestCommandParams.put( - "name", audioOutputrenameOutputRequestnameCommandParameterInfo); - - InteractionInfo audioOutputrenameOutputRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .renameOutputRequest( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("index"), - (String) commandArguments.get("name")); - }, - () -> new DelegatedDefaultClusterCallback(), - audioOutputrenameOutputRequestCommandParams); - audioOutputClusterInteractionInfoMap.put( - "renameOutputRequest", audioOutputrenameOutputRequestInteractionInfo); - Map audioOutputselectOutputRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = - new CommandParameterInfo("index", Integer.class); - audioOutputselectOutputRequestCommandParams.put( - "index", audioOutputselectOutputRequestindexCommandParameterInfo); - - InteractionInfo audioOutputselectOutputRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .selectOutputRequest( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("index")); - }, - () -> new DelegatedDefaultClusterCallback(), - audioOutputselectOutputRequestCommandParams); - audioOutputClusterInteractionInfoMap.put( - "selectOutputRequest", audioOutputselectOutputRequestInteractionInfo); - commandMap.put("audioOutput", audioOutputClusterInteractionInfoMap); - Map barrierControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map barrierControlbarrierControlGoToPercentCommandParams = - new LinkedHashMap(); - CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = - new CommandParameterInfo("percentOpen", Integer.class); - barrierControlbarrierControlGoToPercentCommandParams.put( - "percentOpen", barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); - - InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .barrierControlGoToPercent( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("percentOpen")); - }, - () -> new DelegatedDefaultClusterCallback(), - barrierControlbarrierControlGoToPercentCommandParams); - barrierControlClusterInteractionInfoMap.put( - "barrierControlGoToPercent", barrierControlbarrierControlGoToPercentInteractionInfo); - Map barrierControlbarrierControlStopCommandParams = - new LinkedHashMap(); - InteractionInfo barrierControlbarrierControlStopInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .barrierControlStop((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - barrierControlbarrierControlStopCommandParams); - barrierControlClusterInteractionInfoMap.put( - "barrierControlStop", barrierControlbarrierControlStopInteractionInfo); - commandMap.put("barrierControl", barrierControlClusterInteractionInfoMap); - Map basicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("basic", basicClusterInteractionInfoMap); - Map binaryInputBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("binaryInputBasic", binaryInputBasicClusterInteractionInfoMap); - Map bindingClusterInteractionInfoMap = new LinkedHashMap<>(); - Map bindingbindCommandParams = - new LinkedHashMap(); - CommandParameterInfo bindingbindnodeIdCommandParameterInfo = - new CommandParameterInfo("nodeId", Long.class); - bindingbindCommandParams.put("nodeId", bindingbindnodeIdCommandParameterInfo); - - CommandParameterInfo bindingbindgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - bindingbindCommandParams.put("groupId", bindingbindgroupIdCommandParameterInfo); - - CommandParameterInfo bindingbindendpointIdCommandParameterInfo = - new CommandParameterInfo("endpointId", Integer.class); - bindingbindCommandParams.put("endpointId", bindingbindendpointIdCommandParameterInfo); - - CommandParameterInfo bindingbindclusterIdCommandParameterInfo = - new CommandParameterInfo("clusterId", Long.class); - bindingbindCommandParams.put("clusterId", bindingbindclusterIdCommandParameterInfo); - - InteractionInfo bindingbindInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .bind( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("nodeId"), - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("endpointId"), - (Long) commandArguments.get("clusterId")); - }, - () -> new DelegatedDefaultClusterCallback(), - bindingbindCommandParams); - bindingClusterInteractionInfoMap.put("bind", bindingbindInteractionInfo); - Map bindingunbindCommandParams = - new LinkedHashMap(); - CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = - new CommandParameterInfo("nodeId", Long.class); - bindingunbindCommandParams.put("nodeId", bindingunbindnodeIdCommandParameterInfo); - - CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - bindingunbindCommandParams.put("groupId", bindingunbindgroupIdCommandParameterInfo); - - CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = - new CommandParameterInfo("endpointId", Integer.class); - bindingunbindCommandParams.put("endpointId", bindingunbindendpointIdCommandParameterInfo); - - CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = - new CommandParameterInfo("clusterId", Long.class); - bindingunbindCommandParams.put("clusterId", bindingunbindclusterIdCommandParameterInfo); - - InteractionInfo bindingunbindInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .unbind( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("nodeId"), - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("endpointId"), - (Long) commandArguments.get("clusterId")); - }, - () -> new DelegatedDefaultClusterCallback(), - bindingunbindCommandParams); - bindingClusterInteractionInfoMap.put("unbind", bindingunbindInteractionInfo); - commandMap.put("binding", bindingClusterInteractionInfoMap); - Map booleanStateClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("booleanState", booleanStateClusterInteractionInfoMap); - Map bridgedActionsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map bridgedActionsdisableActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsdisableActionCommandParams.put( - "actionID", bridgedActionsdisableActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsdisableActionCommandParams.put( - "invokeID", bridgedActionsdisableActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsdisableActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .disableAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsdisableActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "disableAction", bridgedActionsdisableActionInteractionInfo); - Map bridgedActionsdisableActionWithDurationCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsdisableActionWithDurationCommandParams.put( - "actionID", bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsdisableActionWithDurationCommandParams.put( - "invokeID", bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = - new CommandParameterInfo("duration", Long.class); - bridgedActionsdisableActionWithDurationCommandParams.put( - "duration", bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .disableActionWithDuration( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID"), - (Long) commandArguments.get("duration")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsdisableActionWithDurationCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "disableActionWithDuration", bridgedActionsdisableActionWithDurationInteractionInfo); - Map bridgedActionsenableActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsenableActionCommandParams.put( - "actionID", bridgedActionsenableActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsenableActionCommandParams.put( - "invokeID", bridgedActionsenableActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsenableActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .enableAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsenableActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "enableAction", bridgedActionsenableActionInteractionInfo); - Map bridgedActionsenableActionWithDurationCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsenableActionWithDurationCommandParams.put( - "actionID", bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsenableActionWithDurationCommandParams.put( - "invokeID", bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = - new CommandParameterInfo("duration", Long.class); - bridgedActionsenableActionWithDurationCommandParams.put( - "duration", bridgedActionsenableActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .enableActionWithDuration( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID"), - (Long) commandArguments.get("duration")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsenableActionWithDurationCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "enableActionWithDuration", bridgedActionsenableActionWithDurationInteractionInfo); - Map bridgedActionsinstantActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsinstantActionCommandParams.put( - "actionID", bridgedActionsinstantActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsinstantActionCommandParams.put( - "invokeID", bridgedActionsinstantActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsinstantActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .instantAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsinstantActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "instantAction", bridgedActionsinstantActionInteractionInfo); - Map bridgedActionsinstantActionWithTransitionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsinstantActionWithTransitionCommandParams.put( - "actionID", bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsinstantActionWithTransitionCommandParams.put( - "invokeID", bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); - - CommandParameterInfo - bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - bridgedActionsinstantActionWithTransitionCommandParams.put( - "transitionTime", - bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); - - InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .instantActionWithTransition( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID"), - (Integer) commandArguments.get("transitionTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsinstantActionWithTransitionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "instantActionWithTransition", bridgedActionsinstantActionWithTransitionInteractionInfo); - Map bridgedActionspauseActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionspauseActionCommandParams.put( - "actionID", bridgedActionspauseActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionspauseActionCommandParams.put( - "invokeID", bridgedActionspauseActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionspauseActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .pauseAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionspauseActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "pauseAction", bridgedActionspauseActionInteractionInfo); - Map bridgedActionspauseActionWithDurationCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionspauseActionWithDurationCommandParams.put( - "actionID", bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionspauseActionWithDurationCommandParams.put( - "invokeID", bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = - new CommandParameterInfo("duration", Long.class); - bridgedActionspauseActionWithDurationCommandParams.put( - "duration", bridgedActionspauseActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .pauseActionWithDuration( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID"), - (Long) commandArguments.get("duration")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionspauseActionWithDurationCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "pauseActionWithDuration", bridgedActionspauseActionWithDurationInteractionInfo); - Map bridgedActionsresumeActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsresumeActionCommandParams.put( - "actionID", bridgedActionsresumeActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsresumeActionCommandParams.put( - "invokeID", bridgedActionsresumeActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsresumeActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .resumeAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsresumeActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "resumeAction", bridgedActionsresumeActionInteractionInfo); - Map bridgedActionsstartActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstartActionCommandParams.put( - "actionID", bridgedActionsstartActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstartActionCommandParams.put( - "invokeID", bridgedActionsstartActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsstartActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .startAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstartActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "startAction", bridgedActionsstartActionInteractionInfo); - Map bridgedActionsstartActionWithDurationCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstartActionWithDurationCommandParams.put( - "actionID", bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstartActionWithDurationCommandParams.put( - "invokeID", bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = - new CommandParameterInfo("duration", Long.class); - bridgedActionsstartActionWithDurationCommandParams.put( - "duration", bridgedActionsstartActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .startActionWithDuration( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID"), - (Long) commandArguments.get("duration")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstartActionWithDurationCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "startActionWithDuration", bridgedActionsstartActionWithDurationInteractionInfo); - Map bridgedActionsstopActionCommandParams = - new LinkedHashMap(); - CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = - new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstopActionCommandParams.put( - "actionID", bridgedActionsstopActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = - new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstopActionCommandParams.put( - "invokeID", bridgedActionsstopActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsstopActionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .stopAction( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("actionID"), - (Optional) commandArguments.get("invokeID")); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstopActionCommandParams); - bridgedActionsClusterInteractionInfoMap.put( - "stopAction", bridgedActionsstopActionInteractionInfo); - commandMap.put("bridgedActions", bridgedActionsClusterInteractionInfoMap); - Map bridgedDeviceBasicClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInteractionInfoMap); - Map channelClusterInteractionInfoMap = new LinkedHashMap<>(); - Map channelchangeChannelByNumberRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = - new CommandParameterInfo("majorNumber", Integer.class); - channelchangeChannelByNumberRequestCommandParams.put( - "majorNumber", channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); - - CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = - new CommandParameterInfo("minorNumber", Integer.class); - channelchangeChannelByNumberRequestCommandParams.put( - "minorNumber", channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); - - InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .changeChannelByNumberRequest( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("majorNumber"), - (Integer) commandArguments.get("minorNumber")); - }, - () -> new DelegatedDefaultClusterCallback(), - channelchangeChannelByNumberRequestCommandParams); - channelClusterInteractionInfoMap.put( - "changeChannelByNumberRequest", channelchangeChannelByNumberRequestInteractionInfo); - Map channelchangeChannelRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = - new CommandParameterInfo("match", String.class); - channelchangeChannelRequestCommandParams.put( - "match", channelchangeChannelRequestmatchCommandParameterInfo); - - InteractionInfo channelchangeChannelRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .changeChannelRequest( - (ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback, - (String) commandArguments.get("match")); - }, - () -> new DelegatedChangeChannelResponseCallback(), - channelchangeChannelRequestCommandParams); - channelClusterInteractionInfoMap.put( - "changeChannelRequest", channelchangeChannelRequestInteractionInfo); - Map channelskipChannelRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = - new CommandParameterInfo("count", Integer.class); - channelskipChannelRequestCommandParams.put( - "count", channelskipChannelRequestcountCommandParameterInfo); - - InteractionInfo channelskipChannelRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .skipChannelRequest( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("count")); - }, - () -> new DelegatedDefaultClusterCallback(), - channelskipChannelRequestCommandParams); - channelClusterInteractionInfoMap.put( - "skipChannelRequest", channelskipChannelRequestInteractionInfo); - commandMap.put("channel", channelClusterInteractionInfoMap); - Map colorControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map colorControlcolorLoopSetCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = - new CommandParameterInfo("updateFlags", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "updateFlags", colorControlcolorLoopSetupdateFlagsCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = - new CommandParameterInfo("action", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "action", colorControlcolorLoopSetactionCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = - new CommandParameterInfo("direction", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "direction", colorControlcolorLoopSetdirectionCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = - new CommandParameterInfo("time", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "time", colorControlcolorLoopSettimeCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = - new CommandParameterInfo("startHue", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "startHue", colorControlcolorLoopSetstartHueCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "optionsMask", colorControlcolorLoopSetoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlcolorLoopSetCommandParams.put( - "optionsOverride", colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlcolorLoopSetInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .colorLoopSet( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("updateFlags"), - (Integer) commandArguments.get("action"), - (Integer) commandArguments.get("direction"), - (Integer) commandArguments.get("time"), - (Integer) commandArguments.get("startHue"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlcolorLoopSetCommandParams); - colorControlClusterInteractionInfoMap.put( - "colorLoopSet", colorControlcolorLoopSetInteractionInfo); - Map colorControlenhancedMoveHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - colorControlenhancedMoveHueCommandParams.put( - "moveMode", colorControlenhancedMoveHuemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - colorControlenhancedMoveHueCommandParams.put( - "rate", colorControlenhancedMoveHuerateCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveHueCommandParams.put( - "optionsMask", colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveHueCommandParams.put( - "optionsOverride", colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveHueCommandParams); - colorControlClusterInteractionInfoMap.put( - "enhancedMoveHue", colorControlenhancedMoveHueInteractionInfo); - Map colorControlenhancedMoveToHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = - new CommandParameterInfo("enhancedHue", Integer.class); - colorControlenhancedMoveToHueCommandParams.put( - "enhancedHue", colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = - new CommandParameterInfo("direction", Integer.class); - colorControlenhancedMoveToHueCommandParams.put( - "direction", colorControlenhancedMoveToHuedirectionCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedMoveToHueCommandParams.put( - "transitionTime", colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveToHueCommandParams.put( - "optionsMask", colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveToHueCommandParams.put( - "optionsOverride", colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveToHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveToHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("enhancedHue"), - (Integer) commandArguments.get("direction"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveToHueCommandParams); - colorControlClusterInteractionInfoMap.put( - "enhancedMoveToHue", colorControlenhancedMoveToHueInteractionInfo); - Map colorControlenhancedMoveToHueAndSaturationCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = - new CommandParameterInfo("enhancedHue", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put( - "enhancedHue", colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = - new CommandParameterInfo("saturation", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put( - "saturation", colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); - - CommandParameterInfo - colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put( - "transitionTime", - colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put( - "optionsMask", colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo - colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put( - "optionsOverride", - colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveToHueAndSaturation( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("enhancedHue"), - (Integer) commandArguments.get("saturation"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveToHueAndSaturationCommandParams); - colorControlClusterInteractionInfoMap.put( - "enhancedMoveToHueAndSaturation", - colorControlenhancedMoveToHueAndSaturationInteractionInfo); - Map colorControlenhancedStepHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - colorControlenhancedStepHueCommandParams.put( - "stepMode", colorControlenhancedStepHuestepModeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - colorControlenhancedStepHueCommandParams.put( - "stepSize", colorControlenhancedStepHuestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedStepHueCommandParams.put( - "transitionTime", colorControlenhancedStepHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedStepHueCommandParams.put( - "optionsMask", colorControlenhancedStepHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedStepHueCommandParams.put( - "optionsOverride", colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedStepHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedStepHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedStepHueCommandParams); - colorControlClusterInteractionInfoMap.put( - "enhancedStepHue", colorControlenhancedStepHueInteractionInfo); - Map colorControlmoveColorCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = - new CommandParameterInfo("rateX", Integer.class); - colorControlmoveColorCommandParams.put("rateX", colorControlmoveColorrateXCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = - new CommandParameterInfo("rateY", Integer.class); - colorControlmoveColorCommandParams.put("rateY", colorControlmoveColorrateYCommandParameterInfo); - - CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveColorCommandParams.put( - "optionsMask", colorControlmoveColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveColorCommandParams.put( - "optionsOverride", colorControlmoveColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveColorInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveColor( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("rateX"), - (Integer) commandArguments.get("rateY"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveColorCommandParams); - colorControlClusterInteractionInfoMap.put("moveColor", colorControlmoveColorInteractionInfo); - Map colorControlmoveColorTemperatureCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "moveMode", colorControlmoveColorTemperaturemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "rate", colorControlmoveColorTemperaturerateCommandParameterInfo); - - CommandParameterInfo - colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = - new CommandParameterInfo("colorTemperatureMinimum", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "colorTemperatureMinimum", - colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - - CommandParameterInfo - colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = - new CommandParameterInfo("colorTemperatureMaximum", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "colorTemperatureMaximum", - colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "optionsMask", colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveColorTemperatureCommandParams.put( - "optionsOverride", colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveColorTemperatureInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveColorTemperature( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate"), - (Integer) commandArguments.get("colorTemperatureMinimum"), - (Integer) commandArguments.get("colorTemperatureMaximum"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveColorTemperatureCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveColorTemperature", colorControlmoveColorTemperatureInteractionInfo); - Map colorControlmoveHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveHueCommandParams.put( - "moveMode", colorControlmoveHuemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - colorControlmoveHueCommandParams.put("rate", colorControlmoveHuerateCommandParameterInfo); - - CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveHueCommandParams.put( - "optionsMask", colorControlmoveHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveHueCommandParams.put( - "optionsOverride", colorControlmoveHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveHueCommandParams); - colorControlClusterInteractionInfoMap.put("moveHue", colorControlmoveHueInteractionInfo); - Map colorControlmoveSaturationCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveSaturationCommandParams.put( - "moveMode", colorControlmoveSaturationmoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - colorControlmoveSaturationCommandParams.put( - "rate", colorControlmoveSaturationrateCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveSaturationCommandParams.put( - "optionsMask", colorControlmoveSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveSaturationCommandParams.put( - "optionsOverride", colorControlmoveSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveSaturationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveSaturation( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveSaturationCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveSaturation", colorControlmoveSaturationInteractionInfo); - Map colorControlmoveToColorCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = - new CommandParameterInfo("colorX", Integer.class); - colorControlmoveToColorCommandParams.put( - "colorX", colorControlmoveToColorcolorXCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = - new CommandParameterInfo("colorY", Integer.class); - colorControlmoveToColorCommandParams.put( - "colorY", colorControlmoveToColorcolorYCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToColorCommandParams.put( - "transitionTime", colorControlmoveToColortransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToColorCommandParams.put( - "optionsMask", colorControlmoveToColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToColorCommandParams.put( - "optionsOverride", colorControlmoveToColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToColorInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToColor( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("colorX"), - (Integer) commandArguments.get("colorY"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToColorCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveToColor", colorControlmoveToColorInteractionInfo); - Map colorControlmoveToColorTemperatureCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = - new CommandParameterInfo("colorTemperature", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put( - "colorTemperature", colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put( - "transitionTime", colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put( - "optionsMask", colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put( - "optionsOverride", colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToColorTemperature( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("colorTemperature"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToColorTemperatureCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveToColorTemperature", colorControlmoveToColorTemperatureInteractionInfo); - Map colorControlmoveToHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = - new CommandParameterInfo("hue", Integer.class); - colorControlmoveToHueCommandParams.put("hue", colorControlmoveToHuehueCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = - new CommandParameterInfo("direction", Integer.class); - colorControlmoveToHueCommandParams.put( - "direction", colorControlmoveToHuedirectionCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToHueCommandParams.put( - "transitionTime", colorControlmoveToHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToHueCommandParams.put( - "optionsMask", colorControlmoveToHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToHueCommandParams.put( - "optionsOverride", colorControlmoveToHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("hue"), - (Integer) commandArguments.get("direction"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToHueCommandParams); - colorControlClusterInteractionInfoMap.put("moveToHue", colorControlmoveToHueInteractionInfo); - Map colorControlmoveToHueAndSaturationCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = - new CommandParameterInfo("hue", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put( - "hue", colorControlmoveToHueAndSaturationhueCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = - new CommandParameterInfo("saturation", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put( - "saturation", colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put( - "transitionTime", colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put( - "optionsMask", colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put( - "optionsOverride", colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToHueAndSaturation( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("hue"), - (Integer) commandArguments.get("saturation"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToHueAndSaturationCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveToHueAndSaturation", colorControlmoveToHueAndSaturationInteractionInfo); - Map colorControlmoveToSaturationCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = - new CommandParameterInfo("saturation", Integer.class); - colorControlmoveToSaturationCommandParams.put( - "saturation", colorControlmoveToSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToSaturationCommandParams.put( - "transitionTime", colorControlmoveToSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToSaturationCommandParams.put( - "optionsMask", colorControlmoveToSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToSaturationCommandParams.put( - "optionsOverride", colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToSaturationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToSaturation( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("saturation"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToSaturationCommandParams); - colorControlClusterInteractionInfoMap.put( - "moveToSaturation", colorControlmoveToSaturationInteractionInfo); - Map colorControlstepColorCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = - new CommandParameterInfo("stepX", Integer.class); - colorControlstepColorCommandParams.put("stepX", colorControlstepColorstepXCommandParameterInfo); - - CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = - new CommandParameterInfo("stepY", Integer.class); - colorControlstepColorCommandParams.put("stepY", colorControlstepColorstepYCommandParameterInfo); - - CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepColorCommandParams.put( - "transitionTime", colorControlstepColortransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepColorCommandParams.put( - "optionsMask", colorControlstepColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepColorCommandParams.put( - "optionsOverride", colorControlstepColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepColorInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepColor( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepX"), - (Integer) commandArguments.get("stepY"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepColorCommandParams); - colorControlClusterInteractionInfoMap.put("stepColor", colorControlstepColorInteractionInfo); - Map colorControlstepColorTemperatureCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "stepMode", colorControlstepColorTemperaturestepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "stepSize", colorControlstepColorTemperaturestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "transitionTime", colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); - - CommandParameterInfo - colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = - new CommandParameterInfo("colorTemperatureMinimum", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "colorTemperatureMinimum", - colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - - CommandParameterInfo - colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = - new CommandParameterInfo("colorTemperatureMaximum", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "colorTemperatureMaximum", - colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "optionsMask", colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepColorTemperatureCommandParams.put( - "optionsOverride", colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepColorTemperatureInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepColorTemperature( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("colorTemperatureMinimum"), - (Integer) commandArguments.get("colorTemperatureMaximum"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepColorTemperatureCommandParams); - colorControlClusterInteractionInfoMap.put( - "stepColorTemperature", colorControlstepColorTemperatureInteractionInfo); - Map colorControlstepHueCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - colorControlstepHueCommandParams.put( - "stepMode", colorControlstepHuestepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - colorControlstepHueCommandParams.put( - "stepSize", colorControlstepHuestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepHueCommandParams.put( - "transitionTime", colorControlstepHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepHueCommandParams.put( - "optionsMask", colorControlstepHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepHueCommandParams.put( - "optionsOverride", colorControlstepHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepHueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepHue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepHueCommandParams); - colorControlClusterInteractionInfoMap.put("stepHue", colorControlstepHueInteractionInfo); - Map colorControlstepSaturationCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - colorControlstepSaturationCommandParams.put( - "stepMode", colorControlstepSaturationstepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - colorControlstepSaturationCommandParams.put( - "stepSize", colorControlstepSaturationstepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepSaturationCommandParams.put( - "transitionTime", colorControlstepSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepSaturationCommandParams.put( - "optionsMask", colorControlstepSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepSaturationCommandParams.put( - "optionsOverride", colorControlstepSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepSaturationInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepSaturation( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepSaturationCommandParams); - colorControlClusterInteractionInfoMap.put( - "stepSaturation", colorControlstepSaturationInteractionInfo); - Map colorControlstopMoveStepCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = - new CommandParameterInfo("optionsMask", Integer.class); - colorControlstopMoveStepCommandParams.put( - "optionsMask", colorControlstopMoveStepoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = - new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstopMoveStepCommandParams.put( - "optionsOverride", colorControlstopMoveStepoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstopMoveStepInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stopMoveStep( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("optionsMask"), - (Integer) commandArguments.get("optionsOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstopMoveStepCommandParams); - colorControlClusterInteractionInfoMap.put( - "stopMoveStep", colorControlstopMoveStepInteractionInfo); - commandMap.put("colorControl", colorControlClusterInteractionInfoMap); - Map contentLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); - Map contentLauncherlaunchContentRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = - new CommandParameterInfo("autoPlay", Boolean.class); - contentLauncherlaunchContentRequestCommandParams.put( - "autoPlay", contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); - - CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = - new CommandParameterInfo("data", String.class); - contentLauncherlaunchContentRequestCommandParams.put( - "data", contentLauncherlaunchContentRequestdataCommandParameterInfo); - - InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .launchContentRequest( - (ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback, - (Boolean) commandArguments.get("autoPlay"), - (String) commandArguments.get("data"), - (ArrayList) - commandArguments.get("search")); - }, - () -> new DelegatedLaunchResponseCallback(), - contentLauncherlaunchContentRequestCommandParams); - contentLauncherClusterInteractionInfoMap.put( - "launchContentRequest", contentLauncherlaunchContentRequestInteractionInfo); - Map contentLauncherlaunchURLRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = - new CommandParameterInfo("contentURL", String.class); - contentLauncherlaunchURLRequestCommandParams.put( - "contentURL", contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); - - CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = - new CommandParameterInfo("displayString", String.class); - contentLauncherlaunchURLRequestCommandParams.put( - "displayString", contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); - - InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .launchURLRequest( - (ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback, - (String) commandArguments.get("contentURL"), - (String) commandArguments.get("displayString"), - (ChipStructs.ContentLauncherClusterBrandingInformation) - commandArguments.get("brandingInformation")); - }, - () -> new DelegatedLaunchResponseCallback(), - contentLauncherlaunchURLRequestCommandParams); - contentLauncherClusterInteractionInfoMap.put( - "launchURLRequest", contentLauncherlaunchURLRequestInteractionInfo); - commandMap.put("contentLauncher", contentLauncherClusterInteractionInfoMap); - Map descriptorClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("descriptor", descriptorClusterInteractionInfoMap); - Map diagnosticLogsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map diagnosticLogsretrieveLogsRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = - new CommandParameterInfo("intent", Integer.class); - diagnosticLogsretrieveLogsRequestCommandParams.put( - "intent", diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); - - CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = - new CommandParameterInfo("requestedProtocol", Integer.class); - diagnosticLogsretrieveLogsRequestCommandParams.put( - "requestedProtocol", - diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); - - CommandParameterInfo - diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = - new CommandParameterInfo("transferFileDesignator", byte[].class); - diagnosticLogsretrieveLogsRequestCommandParams.put( - "transferFileDesignator", - diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); - - InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .retrieveLogsRequest( - (ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback) callback, - (Integer) commandArguments.get("intent"), - (Integer) commandArguments.get("requestedProtocol"), - (byte[]) commandArguments.get("transferFileDesignator")); - }, - () -> new DelegatedRetrieveLogsResponseCallback(), - diagnosticLogsretrieveLogsRequestCommandParams); - diagnosticLogsClusterInteractionInfoMap.put( - "retrieveLogsRequest", diagnosticLogsretrieveLogsRequestInteractionInfo); - commandMap.put("diagnosticLogs", diagnosticLogsClusterInteractionInfoMap); - Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); - Map doorLockclearCredentialCommandParams = - new LinkedHashMap(); - InteractionInfo doorLockclearCredentialInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearCredential( - (DefaultClusterCallback) callback, - (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearCredentialCommandParams); - doorLockClusterInteractionInfoMap.put( - "clearCredential", doorLockclearCredentialInteractionInfo); - Map doorLockclearUserCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockclearUserCommandParams.put("userIndex", doorLockclearUseruserIndexCommandParameterInfo); - - InteractionInfo doorLockclearUserInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearUser( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("userIndex"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearUserCommandParams); - doorLockClusterInteractionInfoMap.put("clearUser", doorLockclearUserInteractionInfo); - Map doorLockclearWeekDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = - new CommandParameterInfo("weekDayIndex", Integer.class); - doorLockclearWeekDayScheduleCommandParams.put( - "weekDayIndex", doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockclearWeekDayScheduleCommandParams.put( - "userIndex", doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearWeekDaySchedule( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("weekDayIndex"), - (Integer) commandArguments.get("userIndex")); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearWeekDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "clearWeekDaySchedule", doorLockclearWeekDayScheduleInteractionInfo); - Map doorLockclearYearDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = - new CommandParameterInfo("yearDayIndex", Integer.class); - doorLockclearYearDayScheduleCommandParams.put( - "yearDayIndex", doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockclearYearDayScheduleCommandParams.put( - "userIndex", doorLockclearYearDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockclearYearDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearYearDaySchedule( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("yearDayIndex"), - (Integer) commandArguments.get("userIndex")); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearYearDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "clearYearDaySchedule", doorLockclearYearDayScheduleInteractionInfo); - Map doorLockgetCredentialStatusCommandParams = - new LinkedHashMap(); - InteractionInfo doorLockgetCredentialStatusInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getCredentialStatus( - (ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback, - (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential")); - }, - () -> new DelegatedGetCredentialStatusResponseCallback(), - doorLockgetCredentialStatusCommandParams); - doorLockClusterInteractionInfoMap.put( - "getCredentialStatus", doorLockgetCredentialStatusInteractionInfo); - Map doorLockgetUserCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockgetUserCommandParams.put("userIndex", doorLockgetUseruserIndexCommandParameterInfo); - - InteractionInfo doorLockgetUserInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getUser( - (ChipClusters.DoorLockCluster.GetUserResponseCallback) callback, - (Integer) commandArguments.get("userIndex")); - }, - () -> new DelegatedGetUserResponseCallback(), - doorLockgetUserCommandParams); - doorLockClusterInteractionInfoMap.put("getUser", doorLockgetUserInteractionInfo); - Map doorLockgetWeekDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = - new CommandParameterInfo("weekDayIndex", Integer.class); - doorLockgetWeekDayScheduleCommandParams.put( - "weekDayIndex", doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockgetWeekDayScheduleCommandParams.put( - "userIndex", doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getWeekDaySchedule( - (ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback) callback, - (Integer) commandArguments.get("weekDayIndex"), - (Integer) commandArguments.get("userIndex")); - }, - () -> new DelegatedGetWeekDayScheduleResponseCallback(), - doorLockgetWeekDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "getWeekDaySchedule", doorLockgetWeekDayScheduleInteractionInfo); - Map doorLockgetYearDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = - new CommandParameterInfo("yearDayIndex", Integer.class); - doorLockgetYearDayScheduleCommandParams.put( - "yearDayIndex", doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLockgetYearDayScheduleCommandParams.put( - "userIndex", doorLockgetYearDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockgetYearDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getYearDaySchedule( - (ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback) callback, - (Integer) commandArguments.get("yearDayIndex"), - (Integer) commandArguments.get("userIndex")); - }, - () -> new DelegatedGetYearDayScheduleResponseCallback(), - doorLockgetYearDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "getYearDaySchedule", doorLockgetYearDayScheduleInteractionInfo); - Map doorLocklockDoorCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = - new CommandParameterInfo("pinCode", Optional.class); - doorLocklockDoorCommandParams.put("pinCode", doorLocklockDoorpinCodeCommandParameterInfo); - - InteractionInfo doorLocklockDoorInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .lockDoor( - (DefaultClusterCallback) callback, - (Optional) commandArguments.get("pinCode"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocklockDoorCommandParams); - doorLockClusterInteractionInfoMap.put("lockDoor", doorLocklockDoorInteractionInfo); - Map doorLocksetCredentialCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = - new CommandParameterInfo("operationType", Integer.class); - doorLocksetCredentialCommandParams.put( - "operationType", doorLocksetCredentialoperationTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = - new CommandParameterInfo("credentialData", byte[].class); - doorLocksetCredentialCommandParams.put( - "credentialData", doorLocksetCredentialcredentialDataCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLocksetCredentialCommandParams.put( - "userIndex", doorLocksetCredentialuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = - new CommandParameterInfo("userStatus", Integer.class); - doorLocksetCredentialCommandParams.put( - "userStatus", doorLocksetCredentialuserStatusCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = - new CommandParameterInfo("userType", Integer.class); - doorLocksetCredentialCommandParams.put( - "userType", doorLocksetCredentialuserTypeCommandParameterInfo); - - InteractionInfo doorLocksetCredentialInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setCredential( - (ChipClusters.DoorLockCluster.SetCredentialResponseCallback) callback, - (Integer) commandArguments.get("operationType"), - (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential"), - (byte[]) commandArguments.get("credentialData"), - (Integer) commandArguments.get("userIndex"), - (Integer) commandArguments.get("userStatus"), - (Integer) commandArguments.get("userType"), - 10000); - }, - () -> new DelegatedSetCredentialResponseCallback(), - doorLocksetCredentialCommandParams); - doorLockClusterInteractionInfoMap.put("setCredential", doorLocksetCredentialInteractionInfo); - Map doorLocksetUserCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = - new CommandParameterInfo("operationType", Integer.class); - doorLocksetUserCommandParams.put( - "operationType", doorLocksetUseroperationTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLocksetUserCommandParams.put("userIndex", doorLocksetUseruserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = - new CommandParameterInfo("userName", String.class); - doorLocksetUserCommandParams.put("userName", doorLocksetUseruserNameCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = - new CommandParameterInfo("userUniqueId", Long.class); - doorLocksetUserCommandParams.put( - "userUniqueId", doorLocksetUseruserUniqueIdCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = - new CommandParameterInfo("userStatus", Integer.class); - doorLocksetUserCommandParams.put("userStatus", doorLocksetUseruserStatusCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = - new CommandParameterInfo("userType", Integer.class); - doorLocksetUserCommandParams.put("userType", doorLocksetUseruserTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = - new CommandParameterInfo("credentialRule", Integer.class); - doorLocksetUserCommandParams.put( - "credentialRule", doorLocksetUsercredentialRuleCommandParameterInfo); - - InteractionInfo doorLocksetUserInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setUser( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("operationType"), - (Integer) commandArguments.get("userIndex"), - (String) commandArguments.get("userName"), - (Long) commandArguments.get("userUniqueId"), - (Integer) commandArguments.get("userStatus"), - (Integer) commandArguments.get("userType"), - (Integer) commandArguments.get("credentialRule"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetUserCommandParams); - doorLockClusterInteractionInfoMap.put("setUser", doorLocksetUserInteractionInfo); - Map doorLocksetWeekDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = - new CommandParameterInfo("weekDayIndex", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "weekDayIndex", doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "userIndex", doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = - new CommandParameterInfo("daysMask", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "daysMask", doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = - new CommandParameterInfo("startHour", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "startHour", doorLocksetWeekDaySchedulestartHourCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = - new CommandParameterInfo("startMinute", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "startMinute", doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = - new CommandParameterInfo("endHour", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "endHour", doorLocksetWeekDayScheduleendHourCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = - new CommandParameterInfo("endMinute", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put( - "endMinute", doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); - - InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setWeekDaySchedule( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("weekDayIndex"), - (Integer) commandArguments.get("userIndex"), - (Integer) commandArguments.get("daysMask"), - (Integer) commandArguments.get("startHour"), - (Integer) commandArguments.get("startMinute"), - (Integer) commandArguments.get("endHour"), - (Integer) commandArguments.get("endMinute")); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetWeekDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "setWeekDaySchedule", doorLocksetWeekDayScheduleInteractionInfo); - Map doorLocksetYearDayScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = - new CommandParameterInfo("yearDayIndex", Integer.class); - doorLocksetYearDayScheduleCommandParams.put( - "yearDayIndex", doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = - new CommandParameterInfo("userIndex", Integer.class); - doorLocksetYearDayScheduleCommandParams.put( - "userIndex", doorLocksetYearDayScheduleuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = - new CommandParameterInfo("localStartTime", Long.class); - doorLocksetYearDayScheduleCommandParams.put( - "localStartTime", doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = - new CommandParameterInfo("localEndTime", Long.class); - doorLocksetYearDayScheduleCommandParams.put( - "localEndTime", doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); - - InteractionInfo doorLocksetYearDayScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setYearDaySchedule( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("yearDayIndex"), - (Integer) commandArguments.get("userIndex"), - (Long) commandArguments.get("localStartTime"), - (Long) commandArguments.get("localEndTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetYearDayScheduleCommandParams); - doorLockClusterInteractionInfoMap.put( - "setYearDaySchedule", doorLocksetYearDayScheduleInteractionInfo); - Map doorLockunlockDoorCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = - new CommandParameterInfo("pinCode", Optional.class); - doorLockunlockDoorCommandParams.put("pinCode", doorLockunlockDoorpinCodeCommandParameterInfo); - - InteractionInfo doorLockunlockDoorInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .unlockDoor( - (DefaultClusterCallback) callback, - (Optional) commandArguments.get("pinCode"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockunlockDoorCommandParams); - doorLockClusterInteractionInfoMap.put("unlockDoor", doorLockunlockDoorInteractionInfo); - Map doorLockunlockWithTimeoutCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = - new CommandParameterInfo("timeout", Integer.class); - doorLockunlockWithTimeoutCommandParams.put( - "timeout", doorLockunlockWithTimeouttimeoutCommandParameterInfo); - - CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = - new CommandParameterInfo("pinCode", Optional.class); - doorLockunlockWithTimeoutCommandParams.put( - "pinCode", doorLockunlockWithTimeoutpinCodeCommandParameterInfo); - - InteractionInfo doorLockunlockWithTimeoutInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .unlockWithTimeout( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("timeout"), - (Optional) commandArguments.get("pinCode"), - 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockunlockWithTimeoutCommandParams); - doorLockClusterInteractionInfoMap.put( - "unlockWithTimeout", doorLockunlockWithTimeoutInteractionInfo); - commandMap.put("doorLock", doorLockClusterInteractionInfoMap); - Map electricalMeasurementClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("electricalMeasurement", electricalMeasurementClusterInteractionInfoMap); - Map ethernetNetworkDiagnosticsClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map ethernetNetworkDiagnosticsresetCountsCommandParams = - new LinkedHashMap(); - InteractionInfo ethernetNetworkDiagnosticsresetCountsInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - ethernetNetworkDiagnosticsresetCountsCommandParams); - ethernetNetworkDiagnosticsClusterInteractionInfoMap.put( - "resetCounts", ethernetNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put( - "ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); - Map fixedLabelClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("fixedLabel", fixedLabelClusterInteractionInfoMap); - Map flowMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("flowMeasurement", flowMeasurementClusterInteractionInfoMap); - Map generalCommissioningClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map generalCommissioningarmFailSafeCommandParams = - new LinkedHashMap(); - CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = - new CommandParameterInfo("expiryLengthSeconds", Integer.class); - generalCommissioningarmFailSafeCommandParams.put( - "expiryLengthSeconds", - generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); - - CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - generalCommissioningarmFailSafeCommandParams.put( - "breadcrumb", generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); - - CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = - new CommandParameterInfo("timeoutMs", Long.class); - generalCommissioningarmFailSafeCommandParams.put( - "timeoutMs", generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); - - InteractionInfo generalCommissioningarmFailSafeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .armFailSafe( - (ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback) - callback, - (Integer) commandArguments.get("expiryLengthSeconds"), - (Long) commandArguments.get("breadcrumb"), - (Long) commandArguments.get("timeoutMs")); - }, - () -> new DelegatedArmFailSafeResponseCallback(), - generalCommissioningarmFailSafeCommandParams); - generalCommissioningClusterInteractionInfoMap.put( - "armFailSafe", generalCommissioningarmFailSafeInteractionInfo); - Map generalCommissioningcommissioningCompleteCommandParams = - new LinkedHashMap(); - InteractionInfo generalCommissioningcommissioningCompleteInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .commissioningComplete( - (ChipClusters.GeneralCommissioningCluster - .CommissioningCompleteResponseCallback) - callback); - }, - () -> new DelegatedCommissioningCompleteResponseCallback(), - generalCommissioningcommissioningCompleteCommandParams); - generalCommissioningClusterInteractionInfoMap.put( - "commissioningComplete", generalCommissioningcommissioningCompleteInteractionInfo); - Map generalCommissioningsetRegulatoryConfigCommandParams = - new LinkedHashMap(); - CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = - new CommandParameterInfo("location", Integer.class); - generalCommissioningsetRegulatoryConfigCommandParams.put( - "location", generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = - new CommandParameterInfo("countryCode", String.class); - generalCommissioningsetRegulatoryConfigCommandParams.put( - "countryCode", generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - generalCommissioningsetRegulatoryConfigCommandParams.put( - "breadcrumb", generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = - new CommandParameterInfo("timeoutMs", Long.class); - generalCommissioningsetRegulatoryConfigCommandParams.put( - "timeoutMs", generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); - - InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .setRegulatoryConfig( - (ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback) - callback, - (Integer) commandArguments.get("location"), - (String) commandArguments.get("countryCode"), - (Long) commandArguments.get("breadcrumb"), - (Long) commandArguments.get("timeoutMs")); - }, - () -> new DelegatedSetRegulatoryConfigResponseCallback(), - generalCommissioningsetRegulatoryConfigCommandParams); - generalCommissioningClusterInteractionInfoMap.put( - "setRegulatoryConfig", generalCommissioningsetRegulatoryConfigInteractionInfo); - commandMap.put("generalCommissioning", generalCommissioningClusterInteractionInfoMap); - Map generalDiagnosticsClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("generalDiagnostics", generalDiagnosticsClusterInteractionInfoMap); - Map groupKeyManagementClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map groupKeyManagementkeySetReadCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = - new CommandParameterInfo("groupKeySetID", Integer.class); - groupKeyManagementkeySetReadCommandParams.put( - "groupKeySetID", groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetReadInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetRead( - (ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback, - (Integer) commandArguments.get("groupKeySetID")); - }, - () -> new DelegatedKeySetReadResponseCallback(), - groupKeyManagementkeySetReadCommandParams); - groupKeyManagementClusterInteractionInfoMap.put( - "keySetRead", groupKeyManagementkeySetReadInteractionInfo); - Map groupKeyManagementkeySetReadAllIndicesCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = - new CommandParameterInfo("groupKeySetIDs", ArrayList.class); - groupKeyManagementkeySetReadAllIndicesCommandParams.put( - "groupKeySetIDs", groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetReadAllIndices( - (ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) - callback, - (ArrayList) commandArguments.get("groupKeySetIDs")); - }, - () -> new DelegatedKeySetReadAllIndicesResponseCallback(), - groupKeyManagementkeySetReadAllIndicesCommandParams); - groupKeyManagementClusterInteractionInfoMap.put( - "keySetReadAllIndices", groupKeyManagementkeySetReadAllIndicesInteractionInfo); - Map groupKeyManagementkeySetRemoveCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = - new CommandParameterInfo("groupKeySetID", Integer.class); - groupKeyManagementkeySetRemoveCommandParams.put( - "groupKeySetID", groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetRemove( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("groupKeySetID")); - }, - () -> new DelegatedDefaultClusterCallback(), - groupKeyManagementkeySetRemoveCommandParams); - groupKeyManagementClusterInteractionInfoMap.put( - "keySetRemove", groupKeyManagementkeySetRemoveInteractionInfo); - Map groupKeyManagementkeySetWriteCommandParams = - new LinkedHashMap(); - InteractionInfo groupKeyManagementkeySetWriteInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetWrite( - (DefaultClusterCallback) callback, - (ChipStructs.GroupKeyManagementClusterGroupKeySet) - commandArguments.get("groupKeySet")); - }, - () -> new DelegatedDefaultClusterCallback(), - groupKeyManagementkeySetWriteCommandParams); - groupKeyManagementClusterInteractionInfoMap.put( - "keySetWrite", groupKeyManagementkeySetWriteInteractionInfo); - commandMap.put("groupKeyManagement", groupKeyManagementClusterInteractionInfoMap); - Map groupsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map groupsaddGroupCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - groupsaddGroupCommandParams.put("groupId", groupsaddGroupgroupIdCommandParameterInfo); - - CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = - new CommandParameterInfo("groupName", String.class); - groupsaddGroupCommandParams.put("groupName", groupsaddGroupgroupNameCommandParameterInfo); - - InteractionInfo groupsaddGroupInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .addGroup( - (ChipClusters.GroupsCluster.AddGroupResponseCallback) callback, - (Integer) commandArguments.get("groupId"), - (String) commandArguments.get("groupName")); - }, - () -> new DelegatedAddGroupResponseCallback(), - groupsaddGroupCommandParams); - groupsClusterInteractionInfoMap.put("addGroup", groupsaddGroupInteractionInfo); - Map groupsaddGroupIfIdentifyingCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - groupsaddGroupIfIdentifyingCommandParams.put( - "groupId", groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); - - CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = - new CommandParameterInfo("groupName", String.class); - groupsaddGroupIfIdentifyingCommandParams.put( - "groupName", groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); - - InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .addGroupIfIdentifying( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("groupId"), - (String) commandArguments.get("groupName")); - }, - () -> new DelegatedDefaultClusterCallback(), - groupsaddGroupIfIdentifyingCommandParams); - groupsClusterInteractionInfoMap.put( - "addGroupIfIdentifying", groupsaddGroupIfIdentifyingInteractionInfo); - Map groupsgetGroupMembershipCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = - new CommandParameterInfo("groupList", ArrayList.class); - groupsgetGroupMembershipCommandParams.put( - "groupList", groupsgetGroupMembershipgroupListCommandParameterInfo); - - InteractionInfo groupsgetGroupMembershipInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .getGroupMembership( - (ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback, - (ArrayList) commandArguments.get("groupList")); - }, - () -> new DelegatedGetGroupMembershipResponseCallback(), - groupsgetGroupMembershipCommandParams); - groupsClusterInteractionInfoMap.put( - "getGroupMembership", groupsgetGroupMembershipInteractionInfo); - Map groupsremoveAllGroupsCommandParams = - new LinkedHashMap(); - InteractionInfo groupsremoveAllGroupsInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .removeAllGroups((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - groupsremoveAllGroupsCommandParams); - groupsClusterInteractionInfoMap.put("removeAllGroups", groupsremoveAllGroupsInteractionInfo); - Map groupsremoveGroupCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - groupsremoveGroupCommandParams.put("groupId", groupsremoveGroupgroupIdCommandParameterInfo); - - InteractionInfo groupsremoveGroupInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .removeGroup( - (ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback, - (Integer) commandArguments.get("groupId")); - }, - () -> new DelegatedRemoveGroupResponseCallback(), - groupsremoveGroupCommandParams); - groupsClusterInteractionInfoMap.put("removeGroup", groupsremoveGroupInteractionInfo); - Map groupsviewGroupCommandParams = - new LinkedHashMap(); - CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - groupsviewGroupCommandParams.put("groupId", groupsviewGroupgroupIdCommandParameterInfo); - - InteractionInfo groupsviewGroupInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .viewGroup( - (ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback, - (Integer) commandArguments.get("groupId")); - }, - () -> new DelegatedViewGroupResponseCallback(), - groupsviewGroupCommandParams); - groupsClusterInteractionInfoMap.put("viewGroup", groupsviewGroupInteractionInfo); - commandMap.put("groups", groupsClusterInteractionInfoMap); - Map identifyClusterInteractionInfoMap = new LinkedHashMap<>(); - Map identifyidentifyCommandParams = - new LinkedHashMap(); - CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = - new CommandParameterInfo("identifyTime", Integer.class); - identifyidentifyCommandParams.put( - "identifyTime", identifyidentifyidentifyTimeCommandParameterInfo); - - InteractionInfo identifyidentifyInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .identify( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("identifyTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - identifyidentifyCommandParams); - identifyClusterInteractionInfoMap.put("identify", identifyidentifyInteractionInfo); - Map identifyidentifyQueryCommandParams = - new LinkedHashMap(); - InteractionInfo identifyidentifyQueryInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .identifyQuery( - (ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback); - }, - () -> new DelegatedIdentifyQueryResponseCallback(), - identifyidentifyQueryCommandParams); - identifyClusterInteractionInfoMap.put("identifyQuery", identifyidentifyQueryInteractionInfo); - Map identifytriggerEffectCommandParams = - new LinkedHashMap(); - CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = - new CommandParameterInfo("effectIdentifier", Integer.class); - identifytriggerEffectCommandParams.put( - "effectIdentifier", identifytriggerEffecteffectIdentifierCommandParameterInfo); - - CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = - new CommandParameterInfo("effectVariant", Integer.class); - identifytriggerEffectCommandParams.put( - "effectVariant", identifytriggerEffecteffectVariantCommandParameterInfo); - - InteractionInfo identifytriggerEffectInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .triggerEffect( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("effectIdentifier"), - (Integer) commandArguments.get("effectVariant")); - }, - () -> new DelegatedDefaultClusterCallback(), - identifytriggerEffectCommandParams); - identifyClusterInteractionInfoMap.put("triggerEffect", identifytriggerEffectInteractionInfo); - commandMap.put("identify", identifyClusterInteractionInfoMap); - Map illuminanceMeasurementClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInteractionInfoMap); - Map keypadInputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map keypadInputsendKeyRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = - new CommandParameterInfo("keyCode", Integer.class); - keypadInputsendKeyRequestCommandParams.put( - "keyCode", keypadInputsendKeyRequestkeyCodeCommandParameterInfo); - - InteractionInfo keypadInputsendKeyRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .sendKeyRequest( - (ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback, - (Integer) commandArguments.get("keyCode")); - }, - () -> new DelegatedSendKeyResponseCallback(), - keypadInputsendKeyRequestCommandParams); - keypadInputClusterInteractionInfoMap.put( - "sendKeyRequest", keypadInputsendKeyRequestInteractionInfo); - commandMap.put("keypadInput", keypadInputClusterInteractionInfoMap); - Map levelControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map levelControlmoveCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - levelControlmoveCommandParams.put("moveMode", levelControlmovemoveModeCommandParameterInfo); - - CommandParameterInfo levelControlmoverateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - levelControlmoveCommandParams.put("rate", levelControlmoverateCommandParameterInfo); - - CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = - new CommandParameterInfo("optionMask", Integer.class); - levelControlmoveCommandParams.put("optionMask", levelControlmoveoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = - new CommandParameterInfo("optionOverride", Integer.class); - levelControlmoveCommandParams.put( - "optionOverride", levelControlmoveoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlmoveInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .move( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate"), - (Integer) commandArguments.get("optionMask"), - (Integer) commandArguments.get("optionOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveCommandParams); - levelControlClusterInteractionInfoMap.put("move", levelControlmoveInteractionInfo); - Map levelControlmoveToLevelCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = - new CommandParameterInfo("level", Integer.class); - levelControlmoveToLevelCommandParams.put( - "level", levelControlmoveToLevellevelCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - levelControlmoveToLevelCommandParams.put( - "transitionTime", levelControlmoveToLeveltransitionTimeCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = - new CommandParameterInfo("optionMask", Integer.class); - levelControlmoveToLevelCommandParams.put( - "optionMask", levelControlmoveToLeveloptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = - new CommandParameterInfo("optionOverride", Integer.class); - levelControlmoveToLevelCommandParams.put( - "optionOverride", levelControlmoveToLeveloptionOverrideCommandParameterInfo); - - InteractionInfo levelControlmoveToLevelInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveToLevel( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("level"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionMask"), - (Integer) commandArguments.get("optionOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveToLevelCommandParams); - levelControlClusterInteractionInfoMap.put( - "moveToLevel", levelControlmoveToLevelInteractionInfo); - Map levelControlmoveToLevelWithOnOffCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = - new CommandParameterInfo("level", Integer.class); - levelControlmoveToLevelWithOnOffCommandParams.put( - "level", levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - levelControlmoveToLevelWithOnOffCommandParams.put( - "transitionTime", levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); - - InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveToLevelWithOnOff( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("level"), - (Integer) commandArguments.get("transitionTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveToLevelWithOnOffCommandParams); - levelControlClusterInteractionInfoMap.put( - "moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffInteractionInfo); - Map levelControlmoveWithOnOffCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = - new CommandParameterInfo("moveMode", Integer.class); - levelControlmoveWithOnOffCommandParams.put( - "moveMode", levelControlmoveWithOnOffmoveModeCommandParameterInfo); - - CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = - new CommandParameterInfo("rate", Integer.class); - levelControlmoveWithOnOffCommandParams.put( - "rate", levelControlmoveWithOnOffrateCommandParameterInfo); - - InteractionInfo levelControlmoveWithOnOffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveWithOnOff( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("moveMode"), - (Integer) commandArguments.get("rate")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveWithOnOffCommandParams); - levelControlClusterInteractionInfoMap.put( - "moveWithOnOff", levelControlmoveWithOnOffInteractionInfo); - Map levelControlstepCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlstepstepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - levelControlstepCommandParams.put("stepMode", levelControlstepstepModeCommandParameterInfo); - - CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - levelControlstepCommandParams.put("stepSize", levelControlstepstepSizeCommandParameterInfo); - - CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - levelControlstepCommandParams.put( - "transitionTime", levelControlsteptransitionTimeCommandParameterInfo); - - CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = - new CommandParameterInfo("optionMask", Integer.class); - levelControlstepCommandParams.put("optionMask", levelControlstepoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = - new CommandParameterInfo("optionOverride", Integer.class); - levelControlstepCommandParams.put( - "optionOverride", levelControlstepoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlstepInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .step( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime"), - (Integer) commandArguments.get("optionMask"), - (Integer) commandArguments.get("optionOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstepCommandParams); - levelControlClusterInteractionInfoMap.put("step", levelControlstepInteractionInfo); - Map levelControlstepWithOnOffCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = - new CommandParameterInfo("stepMode", Integer.class); - levelControlstepWithOnOffCommandParams.put( - "stepMode", levelControlstepWithOnOffstepModeCommandParameterInfo); - - CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = - new CommandParameterInfo("stepSize", Integer.class); - levelControlstepWithOnOffCommandParams.put( - "stepSize", levelControlstepWithOnOffstepSizeCommandParameterInfo); - - CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - levelControlstepWithOnOffCommandParams.put( - "transitionTime", levelControlstepWithOnOfftransitionTimeCommandParameterInfo); - - InteractionInfo levelControlstepWithOnOffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stepWithOnOff( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("stepMode"), - (Integer) commandArguments.get("stepSize"), - (Integer) commandArguments.get("transitionTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstepWithOnOffCommandParams); - levelControlClusterInteractionInfoMap.put( - "stepWithOnOff", levelControlstepWithOnOffInteractionInfo); - Map levelControlstopCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = - new CommandParameterInfo("optionMask", Integer.class); - levelControlstopCommandParams.put("optionMask", levelControlstopoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = - new CommandParameterInfo("optionOverride", Integer.class); - levelControlstopCommandParams.put( - "optionOverride", levelControlstopoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlstopInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stop( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("optionMask"), - (Integer) commandArguments.get("optionOverride")); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstopCommandParams); - levelControlClusterInteractionInfoMap.put("stop", levelControlstopInteractionInfo); - Map levelControlstopWithOnOffCommandParams = - new LinkedHashMap(); - InteractionInfo levelControlstopWithOnOffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stopWithOnOff((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstopWithOnOffCommandParams); - levelControlClusterInteractionInfoMap.put( - "stopWithOnOff", levelControlstopWithOnOffInteractionInfo); - commandMap.put("levelControl", levelControlClusterInteractionInfoMap); - Map localizationConfigurationClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("localizationConfiguration", localizationConfigurationClusterInteractionInfoMap); - Map lowPowerClusterInteractionInfoMap = new LinkedHashMap<>(); - Map lowPowersleepCommandParams = - new LinkedHashMap(); - InteractionInfo lowPowersleepInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).sleep((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - lowPowersleepCommandParams); - lowPowerClusterInteractionInfoMap.put("sleep", lowPowersleepInteractionInfo); - commandMap.put("lowPower", lowPowerClusterInteractionInfoMap); - Map mediaInputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map mediaInputhideInputStatusRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaInputhideInputStatusRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .hideInputStatusRequest((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputhideInputStatusRequestCommandParams); - mediaInputClusterInteractionInfoMap.put( - "hideInputStatusRequest", mediaInputhideInputStatusRequestInteractionInfo); - Map mediaInputrenameInputRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = - new CommandParameterInfo("index", Integer.class); - mediaInputrenameInputRequestCommandParams.put( - "index", mediaInputrenameInputRequestindexCommandParameterInfo); - - CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = - new CommandParameterInfo("name", String.class); - mediaInputrenameInputRequestCommandParams.put( - "name", mediaInputrenameInputRequestnameCommandParameterInfo); - - InteractionInfo mediaInputrenameInputRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .renameInputRequest( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("index"), - (String) commandArguments.get("name")); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputrenameInputRequestCommandParams); - mediaInputClusterInteractionInfoMap.put( - "renameInputRequest", mediaInputrenameInputRequestInteractionInfo); - Map mediaInputselectInputRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = - new CommandParameterInfo("index", Integer.class); - mediaInputselectInputRequestCommandParams.put( - "index", mediaInputselectInputRequestindexCommandParameterInfo); - - InteractionInfo mediaInputselectInputRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .selectInputRequest( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("index")); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputselectInputRequestCommandParams); - mediaInputClusterInteractionInfoMap.put( - "selectInputRequest", mediaInputselectInputRequestInteractionInfo); - Map mediaInputshowInputStatusRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaInputshowInputStatusRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .showInputStatusRequest((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputshowInputStatusRequestCommandParams); - mediaInputClusterInteractionInfoMap.put( - "showInputStatusRequest", mediaInputshowInputStatusRequestInteractionInfo); - commandMap.put("mediaInput", mediaInputClusterInteractionInfoMap); - Map mediaPlaybackClusterInteractionInfoMap = new LinkedHashMap<>(); - Map mediaPlaybackfastForwardRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackfastForwardRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .fastForwardRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackfastForwardRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "fastForwardRequest", mediaPlaybackfastForwardRequestInteractionInfo); - Map mediaPlaybacknextRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybacknextRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .nextRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybacknextRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "nextRequest", mediaPlaybacknextRequestInteractionInfo); - Map mediaPlaybackpauseRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackpauseRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .pauseRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackpauseRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "pauseRequest", mediaPlaybackpauseRequestInteractionInfo); - Map mediaPlaybackplayRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackplayRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .playRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackplayRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "playRequest", mediaPlaybackplayRequestInteractionInfo); - Map mediaPlaybackpreviousRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackpreviousRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .previousRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackpreviousRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "previousRequest", mediaPlaybackpreviousRequestInteractionInfo); - Map mediaPlaybackrewindRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackrewindRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .rewindRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackrewindRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "rewindRequest", mediaPlaybackrewindRequestInteractionInfo); - Map mediaPlaybackseekRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = - new CommandParameterInfo("position", Long.class); - mediaPlaybackseekRequestCommandParams.put( - "position", mediaPlaybackseekRequestpositionCommandParameterInfo); - - InteractionInfo mediaPlaybackseekRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .seekRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, - (Long) commandArguments.get("position")); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackseekRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "seekRequest", mediaPlaybackseekRequestInteractionInfo); - Map mediaPlaybackskipBackwardRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo - mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = - new CommandParameterInfo("deltaPositionMilliseconds", Long.class); - mediaPlaybackskipBackwardRequestCommandParams.put( - "deltaPositionMilliseconds", - mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); - - InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .skipBackwardRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, - (Long) commandArguments.get("deltaPositionMilliseconds")); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackskipBackwardRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "skipBackwardRequest", mediaPlaybackskipBackwardRequestInteractionInfo); - Map mediaPlaybackskipForwardRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo - mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = - new CommandParameterInfo("deltaPositionMilliseconds", Long.class); - mediaPlaybackskipForwardRequestCommandParams.put( - "deltaPositionMilliseconds", - mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); - - InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .skipForwardRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, - (Long) commandArguments.get("deltaPositionMilliseconds")); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackskipForwardRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "skipForwardRequest", mediaPlaybackskipForwardRequestInteractionInfo); - Map mediaPlaybackstartOverRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackstartOverRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .startOverRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackstartOverRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "startOverRequest", mediaPlaybackstartOverRequestInteractionInfo); - Map mediaPlaybackstopRequestCommandParams = - new LinkedHashMap(); - InteractionInfo mediaPlaybackstopRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .stopRequest( - (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackstopRequestCommandParams); - mediaPlaybackClusterInteractionInfoMap.put( - "stopRequest", mediaPlaybackstopRequestInteractionInfo); - commandMap.put("mediaPlayback", mediaPlaybackClusterInteractionInfoMap); - Map modeSelectClusterInteractionInfoMap = new LinkedHashMap<>(); - Map modeSelectchangeToModeCommandParams = - new LinkedHashMap(); - CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = - new CommandParameterInfo("newMode", Integer.class); - modeSelectchangeToModeCommandParams.put( - "newMode", modeSelectchangeToModenewModeCommandParameterInfo); - - InteractionInfo modeSelectchangeToModeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .changeToMode( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("newMode")); - }, - () -> new DelegatedDefaultClusterCallback(), - modeSelectchangeToModeCommandParams); - modeSelectClusterInteractionInfoMap.put("changeToMode", modeSelectchangeToModeInteractionInfo); - commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); - Map networkCommissioningClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = - new LinkedHashMap(); - CommandParameterInfo - networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = - new CommandParameterInfo("operationalDataset", byte[].class); - networkCommissioningaddOrUpdateThreadNetworkCommandParams.put( - "operationalDataset", - networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); - - CommandParameterInfo - networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningaddOrUpdateThreadNetworkCommandParams.put( - "breadcrumb", networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .addOrUpdateThreadNetwork( - (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) - callback, - (byte[]) commandArguments.get("operationalDataset"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningaddOrUpdateThreadNetworkCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "addOrUpdateThreadNetwork", networkCommissioningaddOrUpdateThreadNetworkInteractionInfo); - Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = - new CommandParameterInfo("ssid", byte[].class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( - "ssid", networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = - new CommandParameterInfo("credentials", byte[].class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( - "credentials", networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( - "breadcrumb", networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .addOrUpdateWiFiNetwork( - (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) - callback, - (byte[]) commandArguments.get("ssid"), - (byte[]) commandArguments.get("credentials"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningaddOrUpdateWiFiNetworkCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "addOrUpdateWiFiNetwork", networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo); - Map networkCommissioningconnectNetworkCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = - new CommandParameterInfo("networkID", byte[].class); - networkCommissioningconnectNetworkCommandParams.put( - "networkID", networkCommissioningconnectNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningconnectNetworkCommandParams.put( - "breadcrumb", networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningconnectNetworkInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .connectNetwork( - (ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback) - callback, - (byte[]) commandArguments.get("networkID"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedConnectNetworkResponseCallback(), - networkCommissioningconnectNetworkCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "connectNetwork", networkCommissioningconnectNetworkInteractionInfo); - Map networkCommissioningremoveNetworkCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = - new CommandParameterInfo("networkID", byte[].class); - networkCommissioningremoveNetworkCommandParams.put( - "networkID", networkCommissioningremoveNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningremoveNetworkCommandParams.put( - "breadcrumb", networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningremoveNetworkInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .removeNetwork( - (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) - callback, - (byte[]) commandArguments.get("networkID"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningremoveNetworkCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "removeNetwork", networkCommissioningremoveNetworkInteractionInfo); - Map networkCommissioningreorderNetworkCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = - new CommandParameterInfo("networkID", byte[].class); - networkCommissioningreorderNetworkCommandParams.put( - "networkID", networkCommissioningreorderNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = - new CommandParameterInfo("networkIndex", Integer.class); - networkCommissioningreorderNetworkCommandParams.put( - "networkIndex", networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); - - CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningreorderNetworkCommandParams.put( - "breadcrumb", networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningreorderNetworkInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .reorderNetwork( - (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) - callback, - (byte[]) commandArguments.get("networkID"), - (Integer) commandArguments.get("networkIndex"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningreorderNetworkCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "reorderNetwork", networkCommissioningreorderNetworkInteractionInfo); - Map networkCommissioningscanNetworksCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = - new CommandParameterInfo("ssid", byte[].class); - networkCommissioningscanNetworksCommandParams.put( - "ssid", networkCommissioningscanNetworksssidCommandParameterInfo); - - CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = - new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningscanNetworksCommandParams.put( - "breadcrumb", networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningscanNetworksInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .scanNetworks( - (ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback) - callback, - (byte[]) commandArguments.get("ssid"), - (Long) commandArguments.get("breadcrumb")); - }, - () -> new DelegatedScanNetworksResponseCallback(), - networkCommissioningscanNetworksCommandParams); - networkCommissioningClusterInteractionInfoMap.put( - "scanNetworks", networkCommissioningscanNetworksInteractionInfo); - commandMap.put("networkCommissioning", networkCommissioningClusterInteractionInfoMap); - Map otaSoftwareUpdateProviderClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo - otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = - new CommandParameterInfo("updateToken", byte[].class); - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put( - "updateToken", otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = - new CommandParameterInfo("newVersion", Long.class); - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put( - "newVersion", otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .applyUpdateRequest( - (ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback) - callback, - (byte[]) commandArguments.get("updateToken"), - (Long) commandArguments.get("newVersion")); - }, - () -> new DelegatedApplyUpdateResponseCallback(), - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put( - "applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo); - Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = - new LinkedHashMap(); - CommandParameterInfo - otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = - new CommandParameterInfo("updateToken", byte[].class); - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put( - "updateToken", otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); - - CommandParameterInfo - otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = - new CommandParameterInfo("softwareVersion", Long.class); - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put( - "softwareVersion", - otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .notifyUpdateApplied( - (DefaultClusterCallback) callback, - (byte[]) commandArguments.get("updateToken"), - (Long) commandArguments.get("softwareVersion")); - }, - () -> new DelegatedDefaultClusterCallback(), - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put( - "notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo); - Map otaSoftwareUpdateProviderqueryImageCommandParams = - new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = - new CommandParameterInfo("vendorId", Integer.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "vendorId", otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = - new CommandParameterInfo("productId", Integer.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "productId", otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = - new CommandParameterInfo("softwareVersion", Long.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "softwareVersion", otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = - new CommandParameterInfo("protocolsSupported", ArrayList.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "protocolsSupported", - otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = - new CommandParameterInfo("hardwareVersion", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "hardwareVersion", otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = - new CommandParameterInfo("location", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "location", otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); - - CommandParameterInfo - otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = - new CommandParameterInfo("requestorCanConsent", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "requestorCanConsent", - otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); - - CommandParameterInfo - otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = - new CommandParameterInfo("metadataForProvider", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put( - "metadataForProvider", - otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .queryImage( - (ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback) - callback, - (Integer) commandArguments.get("vendorId"), - (Integer) commandArguments.get("productId"), - (Long) commandArguments.get("softwareVersion"), - (ArrayList) commandArguments.get("protocolsSupported"), - (Optional) commandArguments.get("hardwareVersion"), - (Optional) commandArguments.get("location"), - (Optional) commandArguments.get("requestorCanConsent"), - (Optional) commandArguments.get("metadataForProvider")); - }, - () -> new DelegatedQueryImageResponseCallback(), - otaSoftwareUpdateProviderqueryImageCommandParams); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put( - "queryImage", otaSoftwareUpdateProviderqueryImageInteractionInfo); - commandMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInteractionInfoMap); - Map otaSoftwareUpdateRequestorClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = - new LinkedHashMap(); - CommandParameterInfo - otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = - new CommandParameterInfo("providerNodeId", Long.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( - "providerNodeId", - otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = - new CommandParameterInfo("vendorId", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( - "vendorId", otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); - - CommandParameterInfo - otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = - new CommandParameterInfo("announcementReason", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( - "announcementReason", - otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); - - CommandParameterInfo - otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = - new CommandParameterInfo("metadataForNode", Optional.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( - "metadataForNode", - otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = - new CommandParameterInfo("endpoint", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( - "endpoint", otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .announceOtaProvider( - (DefaultClusterCallback) callback, - (Long) commandArguments.get("providerNodeId"), - (Integer) commandArguments.get("vendorId"), - (Integer) commandArguments.get("announcementReason"), - (Optional) commandArguments.get("metadataForNode"), - (Integer) commandArguments.get("endpoint")); - }, - () -> new DelegatedDefaultClusterCallback(), - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams); - otaSoftwareUpdateRequestorClusterInteractionInfoMap.put( - "announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo); - commandMap.put( - "otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInteractionInfoMap); - Map occupancySensingClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("occupancySensing", occupancySensingClusterInteractionInfoMap); - Map onOffClusterInteractionInfoMap = new LinkedHashMap<>(); - Map onOffoffCommandParams = - new LinkedHashMap(); - InteractionInfo onOffoffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).off((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffoffCommandParams); - onOffClusterInteractionInfoMap.put("off", onOffoffInteractionInfo); - Map onOffoffWithEffectCommandParams = - new LinkedHashMap(); - CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = - new CommandParameterInfo("effectId", Integer.class); - onOffoffWithEffectCommandParams.put("effectId", onOffoffWithEffecteffectIdCommandParameterInfo); - - CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = - new CommandParameterInfo("effectVariant", Integer.class); - onOffoffWithEffectCommandParams.put( - "effectVariant", onOffoffWithEffecteffectVariantCommandParameterInfo); - - InteractionInfo onOffoffWithEffectInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .offWithEffect( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("effectId"), - (Integer) commandArguments.get("effectVariant")); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffoffWithEffectCommandParams); - onOffClusterInteractionInfoMap.put("offWithEffect", onOffoffWithEffectInteractionInfo); - Map onOffonCommandParams = - new LinkedHashMap(); - InteractionInfo onOffonInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).on((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonCommandParams); - onOffClusterInteractionInfoMap.put("on", onOffonInteractionInfo); - Map onOffonWithRecallGlobalSceneCommandParams = - new LinkedHashMap(); - InteractionInfo onOffonWithRecallGlobalSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .onWithRecallGlobalScene((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonWithRecallGlobalSceneCommandParams); - onOffClusterInteractionInfoMap.put( - "onWithRecallGlobalScene", onOffonWithRecallGlobalSceneInteractionInfo); - Map onOffonWithTimedOffCommandParams = - new LinkedHashMap(); - CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = - new CommandParameterInfo("onOffControl", Integer.class); - onOffonWithTimedOffCommandParams.put( - "onOffControl", onOffonWithTimedOffonOffControlCommandParameterInfo); - - CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = - new CommandParameterInfo("onTime", Integer.class); - onOffonWithTimedOffCommandParams.put("onTime", onOffonWithTimedOffonTimeCommandParameterInfo); - - CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = - new CommandParameterInfo("offWaitTime", Integer.class); - onOffonWithTimedOffCommandParams.put( - "offWaitTime", onOffonWithTimedOffoffWaitTimeCommandParameterInfo); - - InteractionInfo onOffonWithTimedOffInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .onWithTimedOff( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("onOffControl"), - (Integer) commandArguments.get("onTime"), - (Integer) commandArguments.get("offWaitTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonWithTimedOffCommandParams); - onOffClusterInteractionInfoMap.put("onWithTimedOff", onOffonWithTimedOffInteractionInfo); - Map onOfftoggleCommandParams = - new LinkedHashMap(); - InteractionInfo onOfftoggleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).toggle((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - onOfftoggleCommandParams); - onOffClusterInteractionInfoMap.put("toggle", onOfftoggleInteractionInfo); - commandMap.put("onOff", onOffClusterInteractionInfoMap); - Map onOffSwitchConfigurationClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInteractionInfoMap); - Map operationalCredentialsClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map operationalCredentialsaddNOCCommandParams = - new LinkedHashMap(); - CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = - new CommandParameterInfo("NOCValue", byte[].class); - operationalCredentialsaddNOCCommandParams.put( - "NOCValue", operationalCredentialsaddNOCNOCValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = - new CommandParameterInfo("ICACValue", Optional.class); - operationalCredentialsaddNOCCommandParams.put( - "ICACValue", operationalCredentialsaddNOCICACValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = - new CommandParameterInfo("IPKValue", byte[].class); - operationalCredentialsaddNOCCommandParams.put( - "IPKValue", operationalCredentialsaddNOCIPKValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = - new CommandParameterInfo("caseAdminNode", Long.class); - operationalCredentialsaddNOCCommandParams.put( - "caseAdminNode", operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = - new CommandParameterInfo("adminVendorId", Integer.class); - operationalCredentialsaddNOCCommandParams.put( - "adminVendorId", operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); - - InteractionInfo operationalCredentialsaddNOCInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .addNOC( - (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, - (byte[]) commandArguments.get("NOCValue"), - (Optional) commandArguments.get("ICACValue"), - (byte[]) commandArguments.get("IPKValue"), - (Long) commandArguments.get("caseAdminNode"), - (Integer) commandArguments.get("adminVendorId")); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsaddNOCCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "addNOC", operationalCredentialsaddNOCInteractionInfo); - Map operationalCredentialsaddTrustedRootCertificateCommandParams = - new LinkedHashMap(); - CommandParameterInfo - operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = - new CommandParameterInfo("rootCertificate", byte[].class); - operationalCredentialsaddTrustedRootCertificateCommandParams.put( - "rootCertificate", - operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); - - InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .addTrustedRootCertificate( - (DefaultClusterCallback) callback, - (byte[]) commandArguments.get("rootCertificate")); - }, - () -> new DelegatedDefaultClusterCallback(), - operationalCredentialsaddTrustedRootCertificateCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "addTrustedRootCertificate", - operationalCredentialsaddTrustedRootCertificateInteractionInfo); - Map operationalCredentialsattestationRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo - operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = - new CommandParameterInfo("attestationNonce", byte[].class); - operationalCredentialsattestationRequestCommandParams.put( - "attestationNonce", - operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); - - InteractionInfo operationalCredentialsattestationRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .attestationRequest( - (ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) - callback, - (byte[]) commandArguments.get("attestationNonce")); - }, - () -> new DelegatedAttestationResponseCallback(), - operationalCredentialsattestationRequestCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "attestationRequest", operationalCredentialsattestationRequestInteractionInfo); - Map operationalCredentialscertificateChainRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo - operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = - new CommandParameterInfo("certificateType", Integer.class); - operationalCredentialscertificateChainRequestCommandParams.put( - "certificateType", - operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); - - InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .certificateChainRequest( - (ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) - callback, - (Integer) commandArguments.get("certificateType")); - }, - () -> new DelegatedCertificateChainResponseCallback(), - operationalCredentialscertificateChainRequestCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "certificateChainRequest", operationalCredentialscertificateChainRequestInteractionInfo); - Map operationalCredentialsopCSRRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = - new CommandParameterInfo("CSRNonce", byte[].class); - operationalCredentialsopCSRRequestCommandParams.put( - "CSRNonce", operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); - - InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .opCSRRequest( - (ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback, - (byte[]) commandArguments.get("CSRNonce")); - }, - () -> new DelegatedOpCSRResponseCallback(), - operationalCredentialsopCSRRequestCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "opCSRRequest", operationalCredentialsopCSRRequestInteractionInfo); - Map operationalCredentialsremoveFabricCommandParams = - new LinkedHashMap(); - CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = - new CommandParameterInfo("fabricIndex", Integer.class); - operationalCredentialsremoveFabricCommandParams.put( - "fabricIndex", operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); - - InteractionInfo operationalCredentialsremoveFabricInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .removeFabric( - (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, - (Integer) commandArguments.get("fabricIndex")); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsremoveFabricCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "removeFabric", operationalCredentialsremoveFabricInteractionInfo); - Map - operationalCredentialsremoveTrustedRootCertificateCommandParams = - new LinkedHashMap(); - CommandParameterInfo - operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = - new CommandParameterInfo("trustedRootIdentifier", byte[].class); - operationalCredentialsremoveTrustedRootCertificateCommandParams.put( - "trustedRootIdentifier", - operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); - - InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .removeTrustedRootCertificate( - (DefaultClusterCallback) callback, - (byte[]) commandArguments.get("trustedRootIdentifier")); - }, - () -> new DelegatedDefaultClusterCallback(), - operationalCredentialsremoveTrustedRootCertificateCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "removeTrustedRootCertificate", - operationalCredentialsremoveTrustedRootCertificateInteractionInfo); - Map operationalCredentialsupdateFabricLabelCommandParams = - new LinkedHashMap(); - CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = - new CommandParameterInfo("label", String.class); - operationalCredentialsupdateFabricLabelCommandParams.put( - "label", operationalCredentialsupdateFabricLabellabelCommandParameterInfo); - - InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .updateFabricLabel( - (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, - (String) commandArguments.get("label")); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsupdateFabricLabelCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "updateFabricLabel", operationalCredentialsupdateFabricLabelInteractionInfo); - Map operationalCredentialsupdateNOCCommandParams = - new LinkedHashMap(); - CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = - new CommandParameterInfo("NOCValue", byte[].class); - operationalCredentialsupdateNOCCommandParams.put( - "NOCValue", operationalCredentialsupdateNOCNOCValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = - new CommandParameterInfo("ICACValue", Optional.class); - operationalCredentialsupdateNOCCommandParams.put( - "ICACValue", operationalCredentialsupdateNOCICACValueCommandParameterInfo); - - InteractionInfo operationalCredentialsupdateNOCInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .updateNOC( - (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, - (byte[]) commandArguments.get("NOCValue"), - (Optional) commandArguments.get("ICACValue")); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsupdateNOCCommandParams); - operationalCredentialsClusterInteractionInfoMap.put( - "updateNOC", operationalCredentialsupdateNOCInteractionInfo); - commandMap.put("operationalCredentials", operationalCredentialsClusterInteractionInfoMap); - Map powerSourceClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("powerSource", powerSourceClusterInteractionInfoMap); - Map powerSourceConfigurationClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInteractionInfoMap); - Map pressureMeasurementClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("pressureMeasurement", pressureMeasurementClusterInteractionInfoMap); - Map pumpConfigurationAndControlClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put( - "pumpConfigurationAndControl", pumpConfigurationAndControlClusterInteractionInfoMap); - Map relativeHumidityMeasurementClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put( - "relativeHumidityMeasurement", relativeHumidityMeasurementClusterInteractionInfoMap); - Map scenesClusterInteractionInfoMap = new LinkedHashMap<>(); - Map scenesaddSceneCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesaddSceneCommandParams.put("groupId", scenesaddScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = - new CommandParameterInfo("sceneId", Integer.class); - scenesaddSceneCommandParams.put("sceneId", scenesaddScenesceneIdCommandParameterInfo); - - CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - scenesaddSceneCommandParams.put( - "transitionTime", scenesaddScenetransitionTimeCommandParameterInfo); - - CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = - new CommandParameterInfo("sceneName", String.class); - scenesaddSceneCommandParams.put("sceneName", scenesaddScenesceneNameCommandParameterInfo); - - InteractionInfo scenesaddSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .addScene( - (ChipClusters.ScenesCluster.AddSceneResponseCallback) callback, - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("sceneId"), - (Integer) commandArguments.get("transitionTime"), - (String) commandArguments.get("sceneName"), - (ArrayList) - commandArguments.get("extensionFieldSets")); - }, - () -> new DelegatedAddSceneResponseCallback(), - scenesaddSceneCommandParams); - scenesClusterInteractionInfoMap.put("addScene", scenesaddSceneInteractionInfo); - Map scenesgetSceneMembershipCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesgetSceneMembershipCommandParams.put( - "groupId", scenesgetSceneMembershipgroupIdCommandParameterInfo); - - InteractionInfo scenesgetSceneMembershipInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .getSceneMembership( - (ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback, - (Integer) commandArguments.get("groupId")); - }, - () -> new DelegatedGetSceneMembershipResponseCallback(), - scenesgetSceneMembershipCommandParams); - scenesClusterInteractionInfoMap.put( - "getSceneMembership", scenesgetSceneMembershipInteractionInfo); - Map scenesrecallSceneCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesrecallSceneCommandParams.put("groupId", scenesrecallScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = - new CommandParameterInfo("sceneId", Integer.class); - scenesrecallSceneCommandParams.put("sceneId", scenesrecallScenesceneIdCommandParameterInfo); - - CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = - new CommandParameterInfo("transitionTime", Integer.class); - scenesrecallSceneCommandParams.put( - "transitionTime", scenesrecallScenetransitionTimeCommandParameterInfo); - - InteractionInfo scenesrecallSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .recallScene( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("sceneId"), - (Integer) commandArguments.get("transitionTime")); - }, - () -> new DelegatedDefaultClusterCallback(), - scenesrecallSceneCommandParams); - scenesClusterInteractionInfoMap.put("recallScene", scenesrecallSceneInteractionInfo); - Map scenesremoveAllScenesCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesremoveAllScenesCommandParams.put( - "groupId", scenesremoveAllScenesgroupIdCommandParameterInfo); - - InteractionInfo scenesremoveAllScenesInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .removeAllScenes( - (ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback, - (Integer) commandArguments.get("groupId")); - }, - () -> new DelegatedRemoveAllScenesResponseCallback(), - scenesremoveAllScenesCommandParams); - scenesClusterInteractionInfoMap.put("removeAllScenes", scenesremoveAllScenesInteractionInfo); - Map scenesremoveSceneCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesremoveSceneCommandParams.put("groupId", scenesremoveScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = - new CommandParameterInfo("sceneId", Integer.class); - scenesremoveSceneCommandParams.put("sceneId", scenesremoveScenesceneIdCommandParameterInfo); - - InteractionInfo scenesremoveSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .removeScene( - (ChipClusters.ScenesCluster.RemoveSceneResponseCallback) callback, - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("sceneId")); - }, - () -> new DelegatedRemoveSceneResponseCallback(), - scenesremoveSceneCommandParams); - scenesClusterInteractionInfoMap.put("removeScene", scenesremoveSceneInteractionInfo); - Map scenesstoreSceneCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesstoreSceneCommandParams.put("groupId", scenesstoreScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = - new CommandParameterInfo("sceneId", Integer.class); - scenesstoreSceneCommandParams.put("sceneId", scenesstoreScenesceneIdCommandParameterInfo); - - InteractionInfo scenesstoreSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .storeScene( - (ChipClusters.ScenesCluster.StoreSceneResponseCallback) callback, - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("sceneId")); - }, - () -> new DelegatedStoreSceneResponseCallback(), - scenesstoreSceneCommandParams); - scenesClusterInteractionInfoMap.put("storeScene", scenesstoreSceneInteractionInfo); - Map scenesviewSceneCommandParams = - new LinkedHashMap(); - CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = - new CommandParameterInfo("groupId", Integer.class); - scenesviewSceneCommandParams.put("groupId", scenesviewScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = - new CommandParameterInfo("sceneId", Integer.class); - scenesviewSceneCommandParams.put("sceneId", scenesviewScenesceneIdCommandParameterInfo); - - InteractionInfo scenesviewSceneInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .viewScene( - (ChipClusters.ScenesCluster.ViewSceneResponseCallback) callback, - (Integer) commandArguments.get("groupId"), - (Integer) commandArguments.get("sceneId")); - }, - () -> new DelegatedViewSceneResponseCallback(), - scenesviewSceneCommandParams); - scenesClusterInteractionInfoMap.put("viewScene", scenesviewSceneInteractionInfo); - commandMap.put("scenes", scenesClusterInteractionInfoMap); - Map softwareDiagnosticsClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map softwareDiagnosticsresetWatermarksCommandParams = - new LinkedHashMap(); - InteractionInfo softwareDiagnosticsresetWatermarksInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .resetWatermarks((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - softwareDiagnosticsresetWatermarksCommandParams); - softwareDiagnosticsClusterInteractionInfoMap.put( - "resetWatermarks", softwareDiagnosticsresetWatermarksInteractionInfo); - commandMap.put("softwareDiagnostics", softwareDiagnosticsClusterInteractionInfoMap); - Map switchClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("switch", switchClusterInteractionInfoMap); - Map targetNavigatorClusterInteractionInfoMap = new LinkedHashMap<>(); - Map targetNavigatornavigateTargetRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = - new CommandParameterInfo("target", Integer.class); - targetNavigatornavigateTargetRequestCommandParams.put( - "target", targetNavigatornavigateTargetRequesttargetCommandParameterInfo); - - CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = - new CommandParameterInfo("data", String.class); - targetNavigatornavigateTargetRequestCommandParams.put( - "data", targetNavigatornavigateTargetRequestdataCommandParameterInfo); - - InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .navigateTargetRequest( - (ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback) callback, - (Integer) commandArguments.get("target"), - (String) commandArguments.get("data")); - }, - () -> new DelegatedNavigateTargetResponseCallback(), - targetNavigatornavigateTargetRequestCommandParams); - targetNavigatorClusterInteractionInfoMap.put( - "navigateTargetRequest", targetNavigatornavigateTargetRequestInteractionInfo); - commandMap.put("targetNavigator", targetNavigatorClusterInteractionInfoMap); - Map temperatureMeasurementClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); - Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); - Map testClustersimpleStructEchoRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustersimpleStructEchoRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .simpleStructEchoRequest( - (ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback, - (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1")); - }, - () -> new DelegatedSimpleStructResponseCallback(), - testClustersimpleStructEchoRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "simpleStructEchoRequest", testClustersimpleStructEchoRequestInteractionInfo); - Map testClustertestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).test((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestCommandParams); - testClusterClusterInteractionInfoMap.put("test", testClustertestInteractionInfo); - Map testClustertestAddArgumentsCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = - new CommandParameterInfo("arg1", Integer.class); - testClustertestAddArgumentsCommandParams.put( - "arg1", testClustertestAddArgumentsarg1CommandParameterInfo); - - CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = - new CommandParameterInfo("arg2", Integer.class); - testClustertestAddArgumentsCommandParams.put( - "arg2", testClustertestAddArgumentsarg2CommandParameterInfo); - - InteractionInfo testClustertestAddArgumentsInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testAddArguments( - (ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback) callback, - (Integer) commandArguments.get("arg1"), - (Integer) commandArguments.get("arg2")); - }, - () -> new DelegatedTestAddArgumentsResponseCallback(), - testClustertestAddArgumentsCommandParams); - testClusterClusterInteractionInfoMap.put( - "testAddArguments", testClustertestAddArgumentsInteractionInfo); - Map testClustertestEmitTestEventRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", Integer.class); - testClustertestEmitTestEventRequestCommandParams.put( - "arg1", testClustertestEmitTestEventRequestarg1CommandParameterInfo); - - CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = - new CommandParameterInfo("arg2", Integer.class); - testClustertestEmitTestEventRequestCommandParams.put( - "arg2", testClustertestEmitTestEventRequestarg2CommandParameterInfo); - - CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = - new CommandParameterInfo("arg3", Boolean.class); - testClustertestEmitTestEventRequestCommandParams.put( - "arg3", testClustertestEmitTestEventRequestarg3CommandParameterInfo); - - InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testEmitTestEventRequest( - (ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback) callback, - (Integer) commandArguments.get("arg1"), - (Integer) commandArguments.get("arg2"), - (Boolean) commandArguments.get("arg3")); - }, - () -> new DelegatedTestEmitTestEventResponseCallback(), - testClustertestEmitTestEventRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testEmitTestEventRequest", testClustertestEmitTestEventRequestInteractionInfo); - Map testClustertestEnumsRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", Integer.class); - testClustertestEnumsRequestCommandParams.put( - "arg1", testClustertestEnumsRequestarg1CommandParameterInfo); - - CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = - new CommandParameterInfo("arg2", Integer.class); - testClustertestEnumsRequestCommandParams.put( - "arg2", testClustertestEnumsRequestarg2CommandParameterInfo); - - InteractionInfo testClustertestEnumsRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testEnumsRequest( - (ChipClusters.TestClusterCluster.TestEnumsResponseCallback) callback, - (Integer) commandArguments.get("arg1"), - (Integer) commandArguments.get("arg2")); - }, - () -> new DelegatedTestEnumsResponseCallback(), - testClustertestEnumsRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testEnumsRequest", testClustertestEnumsRequestInteractionInfo); - Map testClustertestListInt8UArgumentRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", ArrayList.class); - testClustertestListInt8UArgumentRequestCommandParams.put( - "arg1", testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListInt8UArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ArrayList) commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListInt8UArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestInteractionInfo); - Map testClustertestListInt8UReverseRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", ArrayList.class); - testClustertestListInt8UReverseRequestCommandParams.put( - "arg1", testClustertestListInt8UReverseRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListInt8UReverseRequest( - (ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) - callback, - (ArrayList) commandArguments.get("arg1")); - }, - () -> new DelegatedTestListInt8UReverseResponseCallback(), - testClustertestListInt8UReverseRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testListInt8UReverseRequest", testClustertestListInt8UReverseRequestInteractionInfo); - Map - testClustertestListNestedStructListArgumentRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestListNestedStructListArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListNestedStructListArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ArrayList) - commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListNestedStructListArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testListNestedStructListArgumentRequest", - testClustertestListNestedStructListArgumentRequestInteractionInfo); - Map testClustertestListStructArgumentRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListStructArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ArrayList) - commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListStructArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testListStructArgumentRequest", testClustertestListStructArgumentRequestInteractionInfo); - Map testClustertestNestedStructArgumentRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestNestedStructArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNestedStructArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ChipStructs.TestClusterClusterNestedStruct) commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestNestedStructArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testNestedStructArgumentRequest", - testClustertestNestedStructArgumentRequestInteractionInfo); - Map testClustertestNestedStructListArgumentRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestNestedStructListArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNestedStructListArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ChipStructs.TestClusterClusterNestedStructList) - commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestNestedStructListArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testNestedStructListArgumentRequest", - testClustertestNestedStructListArgumentRequestInteractionInfo); - Map testClustertestNotHandledCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestNotHandledInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNotHandled((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestNotHandledCommandParams); - testClusterClusterInteractionInfoMap.put( - "testNotHandled", testClustertestNotHandledInteractionInfo); - Map testClustertestNullableOptionalRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", Optional.class); - testClustertestNullableOptionalRequestCommandParams.put( - "arg1", testClustertestNullableOptionalRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNullableOptionalRequest( - (ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) - callback, - (Optional) commandArguments.get("arg1")); - }, - () -> new DelegatedTestNullableOptionalResponseCallback(), - testClustertestNullableOptionalRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testNullableOptionalRequest", testClustertestNullableOptionalRequestInteractionInfo); - Map testClustertestSimpleOptionalArgumentRequestCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = - new CommandParameterInfo("arg1", Optional.class); - testClustertestSimpleOptionalArgumentRequestCommandParams.put( - "arg1", testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testSimpleOptionalArgumentRequest( - (DefaultClusterCallback) callback, - (Optional) commandArguments.get("arg1")); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestSimpleOptionalArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testSimpleOptionalArgumentRequest", - testClustertestSimpleOptionalArgumentRequestInteractionInfo); - Map testClustertestSpecificCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestSpecificInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testSpecific( - (ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback); - }, - () -> new DelegatedTestSpecificResponseCallback(), - testClustertestSpecificCommandParams); - testClusterClusterInteractionInfoMap.put( - "testSpecific", testClustertestSpecificInteractionInfo); - Map testClustertestStructArgumentRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestStructArgumentRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testStructArgumentRequest( - (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, - (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1")); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestStructArgumentRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "testStructArgumentRequest", testClustertestStructArgumentRequestInteractionInfo); - Map testClustertestUnknownCommandCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertestUnknownCommandInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testUnknownCommand((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestUnknownCommandCommandParams); - testClusterClusterInteractionInfoMap.put( - "testUnknownCommand", testClustertestUnknownCommandInteractionInfo); - Map testClustertimedInvokeRequestCommandParams = - new LinkedHashMap(); - InteractionInfo testClustertimedInvokeRequestInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .timedInvokeRequest((DefaultClusterCallback) callback, 10000); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertimedInvokeRequestCommandParams); - testClusterClusterInteractionInfoMap.put( - "timedInvokeRequest", testClustertimedInvokeRequestInteractionInfo); - commandMap.put("testCluster", testClusterClusterInteractionInfoMap); - Map thermostatClusterInteractionInfoMap = new LinkedHashMap<>(); - Map thermostatclearWeeklyScheduleCommandParams = - new LinkedHashMap(); - InteractionInfo thermostatclearWeeklyScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .clearWeeklySchedule((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatclearWeeklyScheduleCommandParams); - thermostatClusterInteractionInfoMap.put( - "clearWeeklySchedule", thermostatclearWeeklyScheduleInteractionInfo); - Map thermostatgetRelayStatusLogCommandParams = - new LinkedHashMap(); - InteractionInfo thermostatgetRelayStatusLogInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .getRelayStatusLog( - (ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback); - }, - () -> new DelegatedGetRelayStatusLogResponseCallback(), - thermostatgetRelayStatusLogCommandParams); - thermostatClusterInteractionInfoMap.put( - "getRelayStatusLog", thermostatgetRelayStatusLogInteractionInfo); - Map thermostatgetWeeklyScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = - new CommandParameterInfo("daysToReturn", Integer.class); - thermostatgetWeeklyScheduleCommandParams.put( - "daysToReturn", thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); - - CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = - new CommandParameterInfo("modeToReturn", Integer.class); - thermostatgetWeeklyScheduleCommandParams.put( - "modeToReturn", thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); - - InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .getWeeklySchedule( - (ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback) callback, - (Integer) commandArguments.get("daysToReturn"), - (Integer) commandArguments.get("modeToReturn")); - }, - () -> new DelegatedGetWeeklyScheduleResponseCallback(), - thermostatgetWeeklyScheduleCommandParams); - thermostatClusterInteractionInfoMap.put( - "getWeeklySchedule", thermostatgetWeeklyScheduleInteractionInfo); - Map thermostatsetWeeklyScheduleCommandParams = - new LinkedHashMap(); - CommandParameterInfo - thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = - new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put( - "numberOfTransitionsForSequence", - thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = - new CommandParameterInfo("dayOfWeekForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put( - "dayOfWeekForSequence", - thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = - new CommandParameterInfo("modeForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put( - "modeForSequence", thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = - new CommandParameterInfo("payload", ArrayList.class); - thermostatsetWeeklyScheduleCommandParams.put( - "payload", thermostatsetWeeklySchedulepayloadCommandParameterInfo); - - InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .setWeeklySchedule( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("numberOfTransitionsForSequence"), - (Integer) commandArguments.get("dayOfWeekForSequence"), - (Integer) commandArguments.get("modeForSequence"), - (ArrayList) commandArguments.get("payload")); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatsetWeeklyScheduleCommandParams); - thermostatClusterInteractionInfoMap.put( - "setWeeklySchedule", thermostatsetWeeklyScheduleInteractionInfo); - Map thermostatsetpointRaiseLowerCommandParams = - new LinkedHashMap(); - CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = - new CommandParameterInfo("mode", Integer.class); - thermostatsetpointRaiseLowerCommandParams.put( - "mode", thermostatsetpointRaiseLowermodeCommandParameterInfo); - - CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = - new CommandParameterInfo("amount", Integer.class); - thermostatsetpointRaiseLowerCommandParams.put( - "amount", thermostatsetpointRaiseLoweramountCommandParameterInfo); - - InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .setpointRaiseLower( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("mode"), - (Integer) commandArguments.get("amount")); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatsetpointRaiseLowerCommandParams); - thermostatClusterInteractionInfoMap.put( - "setpointRaiseLower", thermostatsetpointRaiseLowerInteractionInfo); - commandMap.put("thermostat", thermostatClusterInteractionInfoMap); - Map thermostatUserInterfaceConfigurationClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put( - "thermostatUserInterfaceConfiguration", - thermostatUserInterfaceConfigurationClusterInteractionInfoMap); - Map threadNetworkDiagnosticsClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map threadNetworkDiagnosticsresetCountsCommandParams = - new LinkedHashMap(); - InteractionInfo threadNetworkDiagnosticsresetCountsInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - threadNetworkDiagnosticsresetCountsCommandParams); - threadNetworkDiagnosticsClusterInteractionInfoMap.put( - "resetCounts", threadNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInteractionInfoMap); - Map timeFormatLocalizationClusterInteractionInfoMap = - new LinkedHashMap<>(); - commandMap.put("timeFormatLocalization", timeFormatLocalizationClusterInteractionInfoMap); - Map unitLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("unitLocalization", unitLocalizationClusterInteractionInfoMap); - Map userLabelClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("userLabel", userLabelClusterInteractionInfoMap); - Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); - Map wiFiNetworkDiagnosticsClusterInteractionInfoMap = - new LinkedHashMap<>(); - Map wiFiNetworkDiagnosticsresetCountsCommandParams = - new LinkedHashMap(); - InteractionInfo wiFiNetworkDiagnosticsresetCountsInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - wiFiNetworkDiagnosticsresetCountsCommandParams); - wiFiNetworkDiagnosticsClusterInteractionInfoMap.put( - "resetCounts", wiFiNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInteractionInfoMap); - Map windowCoveringClusterInteractionInfoMap = new LinkedHashMap<>(); - Map windowCoveringdownOrCloseCommandParams = - new LinkedHashMap(); - InteractionInfo windowCoveringdownOrCloseInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .downOrClose((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringdownOrCloseCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "downOrClose", windowCoveringdownOrCloseInteractionInfo); - Map windowCoveringgoToLiftPercentageCommandParams = - new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = - new CommandParameterInfo("liftPercentageValue", Integer.class); - windowCoveringgoToLiftPercentageCommandParams.put( - "liftPercentageValue", - windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); - - CommandParameterInfo - windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = - new CommandParameterInfo("liftPercent100thsValue", Integer.class); - windowCoveringgoToLiftPercentageCommandParams.put( - "liftPercent100thsValue", - windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToLiftPercentage( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("liftPercentageValue"), - (Integer) commandArguments.get("liftPercent100thsValue")); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToLiftPercentageCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "goToLiftPercentage", windowCoveringgoToLiftPercentageInteractionInfo); - Map windowCoveringgoToLiftValueCommandParams = - new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = - new CommandParameterInfo("liftValue", Integer.class); - windowCoveringgoToLiftValueCommandParams.put( - "liftValue", windowCoveringgoToLiftValueliftValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToLiftValueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToLiftValue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("liftValue")); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToLiftValueCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "goToLiftValue", windowCoveringgoToLiftValueInteractionInfo); - Map windowCoveringgoToTiltPercentageCommandParams = - new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = - new CommandParameterInfo("tiltPercentageValue", Integer.class); - windowCoveringgoToTiltPercentageCommandParams.put( - "tiltPercentageValue", - windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); - - CommandParameterInfo - windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = - new CommandParameterInfo("tiltPercent100thsValue", Integer.class); - windowCoveringgoToTiltPercentageCommandParams.put( - "tiltPercent100thsValue", - windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToTiltPercentage( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("tiltPercentageValue"), - (Integer) commandArguments.get("tiltPercent100thsValue")); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToTiltPercentageCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "goToTiltPercentage", windowCoveringgoToTiltPercentageInteractionInfo); - Map windowCoveringgoToTiltValueCommandParams = - new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = - new CommandParameterInfo("tiltValue", Integer.class); - windowCoveringgoToTiltValueCommandParams.put( - "tiltValue", windowCoveringgoToTiltValuetiltValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToTiltValueInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToTiltValue( - (DefaultClusterCallback) callback, - (Integer) commandArguments.get("tiltValue")); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToTiltValueCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "goToTiltValue", windowCoveringgoToTiltValueInteractionInfo); - Map windowCoveringstopMotionCommandParams = - new LinkedHashMap(); - InteractionInfo windowCoveringstopMotionInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .stopMotion((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringstopMotionCommandParams); - windowCoveringClusterInteractionInfoMap.put( - "stopMotion", windowCoveringstopMotionInteractionInfo); - Map windowCoveringupOrOpenCommandParams = - new LinkedHashMap(); - InteractionInfo windowCoveringupOrOpenInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .upOrOpen((DefaultClusterCallback) callback); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringupOrOpenCommandParams); - windowCoveringClusterInteractionInfoMap.put("upOrOpen", windowCoveringupOrOpenInteractionInfo); - commandMap.put("windowCovering", windowCoveringClusterInteractionInfoMap); - return commandMap; - } -} diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java index 2dc210109c6a96..48ec9330a3b2f2 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java @@ -29,8466 +29,8045 @@ public class ClusterReadMapping { public Map> getReadAttributeMap() { Map> readAttributeMap = new HashMap<>(); - Map readAccessControlInteractionInfo = new LinkedHashMap<>(); - Map readAccessControlAclCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlAclAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readAclAttribute( - (ChipClusters.AccessControlCluster.AclAttributeCallback) callback); - }, + Map readAccessControlInteractionInfo = 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); - readAccessControlInteractionInfo.put( - "readAclAttribute", readAccessControlAclAttributeInteractionInfo); - Map readAccessControlExtensionCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlExtensionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readExtensionAttribute( - (ChipClusters.AccessControlCluster.ExtensionAttributeCallback) callback); - }, + readAccessControlAclCommandParams + ); + readAccessControlInteractionInfo.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); - readAccessControlInteractionInfo.put( - "readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); - Map readAccessControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AccessControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAccessControlClusterAttributeListAttributeCallback(), - readAccessControlAttributeListCommandParams); - readAccessControlInteractionInfo.put( - "readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); - Map readAccessControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlClusterRevisionCommandParams); - readAccessControlInteractionInfo.put( - "readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("accessControl", readAccessControlInteractionInfo); - Map readAccountLoginInteractionInfo = new LinkedHashMap<>(); - Map readAccountLoginAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AccountLoginCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), - readAccountLoginAttributeListCommandParams); - readAccountLoginInteractionInfo.put( - "readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); - Map readAccountLoginClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccountLoginClusterRevisionCommandParams); - readAccountLoginInteractionInfo.put( - "readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("accountLogin", readAccountLoginInteractionInfo); - Map readAdministratorCommissioningInteractionInfo = - new LinkedHashMap<>(); - Map readAdministratorCommissioningWindowStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readWindowStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningWindowStatusCommandParams); - readAdministratorCommissioningInteractionInfo.put( - "readWindowStatusAttribute", - readAdministratorCommissioningWindowStatusAttributeInteractionInfo); - Map readAdministratorCommissioningAdminFabricIndexCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readAdminFabricIndexAttribute( - (ChipClusters.AdministratorCommissioningCluster - .AdminFabricIndexAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningAdminFabricIndexCommandParams); - readAdministratorCommissioningInteractionInfo.put( - "readAdminFabricIndexAttribute", - readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); - Map readAdministratorCommissioningAdminVendorIdCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readAdminVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningAdminVendorIdCommandParams); - readAdministratorCommissioningInteractionInfo.put( - "readAdminVendorIdAttribute", - readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); - Map readAdministratorCommissioningAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AdministratorCommissioningCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), - readAdministratorCommissioningAttributeListCommandParams); - readAdministratorCommissioningInteractionInfo.put( - "readAttributeListAttribute", - readAdministratorCommissioningAttributeListAttributeInteractionInfo); - Map readAdministratorCommissioningClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningClusterRevisionCommandParams); - readAdministratorCommissioningInteractionInfo.put( - "readClusterRevisionAttribute", - readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "administratorCommissioning", readAdministratorCommissioningInteractionInfo); - Map readApplicationBasicInteractionInfo = new LinkedHashMap<>(); - Map readApplicationBasicVendorNameCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readAccessControlExtensionCommandParams + ); + readAccessControlInteractionInfo.put("readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); + Map readAccessControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readAttributeListAttribute( + ( ChipClusters.AccessControlCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccessControlClusterAttributeListAttributeCallback(), + readAccessControlAttributeListCommandParams + ); + readAccessControlInteractionInfo.put("readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); + Map readAccessControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlClusterRevisionCommandParams + ); + readAccessControlInteractionInfo.put("readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("accessControl", readAccessControlInteractionInfo); + Map readAccountLoginInteractionInfo = new LinkedHashMap<>(); + Map readAccountLoginAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster).readAttributeListAttribute( + ( ChipClusters.AccountLoginCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), + readAccountLoginAttributeListCommandParams + ); + readAccountLoginInteractionInfo.put("readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); + Map readAccountLoginClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccountLoginClusterRevisionCommandParams + ); + readAccountLoginInteractionInfo.put("readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("accountLogin", readAccountLoginInteractionInfo); + Map readAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readAdministratorCommissioningWindowStatusCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readWindowStatusAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningWindowStatusCommandParams + ); + readAdministratorCommissioningInteractionInfo.put("readWindowStatusAttribute", readAdministratorCommissioningWindowStatusAttributeInteractionInfo); + Map readAdministratorCommissioningAdminFabricIndexCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminFabricIndexAttribute( + ( ChipClusters.AdministratorCommissioningCluster.AdminFabricIndexAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningAdminFabricIndexCommandParams + ); + readAdministratorCommissioningInteractionInfo.put("readAdminFabricIndexAttribute", readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); + Map readAdministratorCommissioningAdminVendorIdCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminVendorIdAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningAdminVendorIdCommandParams + ); + readAdministratorCommissioningInteractionInfo.put("readAdminVendorIdAttribute", readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); + Map readAdministratorCommissioningAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readAttributeListAttribute( + ( ChipClusters.AdministratorCommissioningCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), + readAdministratorCommissioningAttributeListCommandParams + ); + readAdministratorCommissioningInteractionInfo.put("readAttributeListAttribute", readAdministratorCommissioningAttributeListAttributeInteractionInfo); + Map readAdministratorCommissioningClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningClusterRevisionCommandParams + ); + readAdministratorCommissioningInteractionInfo.put("readClusterRevisionAttribute", readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("administratorCommissioning", readAdministratorCommissioningInteractionInfo); + Map readApplicationBasicInteractionInfo = new LinkedHashMap<>(); + Map readApplicationBasicVendorNameCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readVendorNameAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicVendorNameCommandParams); - readApplicationBasicInteractionInfo.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); - readApplicationBasicInteractionInfo.put( - "readVendorIdAttribute", readApplicationBasicVendorIdAttributeInteractionInfo); - Map readApplicationBasicApplicationNameCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readApplicationNameAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readApplicationBasicVendorNameCommandParams + ); + readApplicationBasicInteractionInfo.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 + ); + readApplicationBasicInteractionInfo.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); - readApplicationBasicInteractionInfo.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); - readApplicationBasicInteractionInfo.put( - "readProductIdAttribute", readApplicationBasicProductIdAttributeInteractionInfo); - Map readApplicationBasicApplicationStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readApplicationStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicApplicationStatusCommandParams); - readApplicationBasicInteractionInfo.put( - "readApplicationStatusAttribute", - readApplicationBasicApplicationStatusAttributeInteractionInfo); - Map readApplicationBasicApplicationVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readApplicationVersionAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readApplicationBasicApplicationNameCommandParams + ); + readApplicationBasicInteractionInfo.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 + ); + readApplicationBasicInteractionInfo.put("readProductIdAttribute", readApplicationBasicProductIdAttributeInteractionInfo); + Map readApplicationBasicApplicationStatusCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationStatusAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicApplicationStatusCommandParams + ); + readApplicationBasicInteractionInfo.put("readApplicationStatusAttribute", readApplicationBasicApplicationStatusAttributeInteractionInfo); + Map readApplicationBasicApplicationVersionCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationVersionAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicApplicationVersionCommandParams); - readApplicationBasicInteractionInfo.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); - readApplicationBasicInteractionInfo.put( - "readAllowedVendorListAttribute", - readApplicationBasicAllowedVendorListAttributeInteractionInfo); - Map readApplicationBasicAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationBasicClusterAttributeListAttributeCallback(), - readApplicationBasicAttributeListCommandParams); - readApplicationBasicInteractionInfo.put( - "readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); - Map readApplicationBasicClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicClusterRevisionCommandParams); - readApplicationBasicInteractionInfo.put( - "readClusterRevisionAttribute", - readApplicationBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("applicationBasic", readApplicationBasicInteractionInfo); - Map readApplicationLauncherInteractionInfo = new LinkedHashMap<>(); - Map readApplicationLauncherApplicationLauncherListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherApplicationLauncherListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readApplicationLauncherListAttribute( - (ChipClusters.ApplicationLauncherCluster - .ApplicationLauncherListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback(), - readApplicationLauncherApplicationLauncherListCommandParams); - readApplicationLauncherInteractionInfo.put( - "readApplicationLauncherListAttribute", - readApplicationLauncherApplicationLauncherListAttributeInteractionInfo); - Map readApplicationLauncherAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), - readApplicationLauncherAttributeListCommandParams); - readApplicationLauncherInteractionInfo.put( - "readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); - Map readApplicationLauncherClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationLauncherClusterRevisionCommandParams); - readApplicationLauncherInteractionInfo.put( - "readClusterRevisionAttribute", - readApplicationLauncherClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("applicationLauncher", readApplicationLauncherInteractionInfo); - Map readAudioOutputInteractionInfo = new LinkedHashMap<>(); - Map readAudioOutputAudioOutputListCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputAudioOutputListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readAudioOutputListAttribute( - (ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedAudioOutputClusterAudioOutputListAttributeCallback(), - readAudioOutputAudioOutputListCommandParams); - readAudioOutputInteractionInfo.put( - "readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeInteractionInfo); - Map readAudioOutputCurrentAudioOutputCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputCurrentAudioOutputAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readCurrentAudioOutputAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputCurrentAudioOutputCommandParams); - readAudioOutputInteractionInfo.put( - "readCurrentAudioOutputAttribute", - readAudioOutputCurrentAudioOutputAttributeInteractionInfo); - Map readAudioOutputAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.AudioOutputCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), - readAudioOutputAttributeListCommandParams); - readAudioOutputInteractionInfo.put( - "readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); - Map readAudioOutputClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputClusterRevisionCommandParams); - readAudioOutputInteractionInfo.put( - "readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("audioOutput", readAudioOutputInteractionInfo); - Map readBarrierControlInteractionInfo = new LinkedHashMap<>(); - Map readBarrierControlBarrierMovingStateCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierMovingStateAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierMovingStateCommandParams); - readBarrierControlInteractionInfo.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); - readBarrierControlInteractionInfo.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); - readBarrierControlInteractionInfo.put( - "readBarrierCapabilitiesAttribute", - readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); - Map readBarrierControlBarrierPositionCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readBarrierPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierPositionCommandParams); - readBarrierControlInteractionInfo.put( - "readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); - Map readBarrierControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BarrierControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBarrierControlClusterAttributeListAttributeCallback(), - readBarrierControlAttributeListCommandParams); - readBarrierControlInteractionInfo.put( - "readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); - Map readBarrierControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlClusterRevisionCommandParams); - readBarrierControlInteractionInfo.put( - "readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("barrierControl", readBarrierControlInteractionInfo); - Map readBasicInteractionInfo = new LinkedHashMap<>(); - Map readBasicInteractionModelVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicInteractionModelVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readInteractionModelVersionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInteractionModelVersionCommandParams); - readBasicInteractionInfo.put( - "readInteractionModelVersionAttribute", - readBasicInteractionModelVersionAttributeInteractionInfo); - Map readBasicVendorNameCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicVendorNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readApplicationBasicApplicationVersionCommandParams + ); + readApplicationBasicInteractionInfo.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 + ); + readApplicationBasicInteractionInfo.put("readAllowedVendorListAttribute", readApplicationBasicAllowedVendorListAttributeInteractionInfo); + Map readApplicationBasicAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterAttributeListAttributeCallback(), + readApplicationBasicAttributeListCommandParams + ); + readApplicationBasicInteractionInfo.put("readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); + Map readApplicationBasicClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicClusterRevisionCommandParams + ); + readApplicationBasicInteractionInfo.put("readClusterRevisionAttribute", readApplicationBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationBasic", readApplicationBasicInteractionInfo); + Map readApplicationLauncherInteractionInfo = new LinkedHashMap<>(); + Map readApplicationLauncherApplicationLauncherListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherApplicationLauncherListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readApplicationLauncherListAttribute( + ( ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback(), + readApplicationLauncherApplicationLauncherListCommandParams + ); + readApplicationLauncherInteractionInfo.put("readApplicationLauncherListAttribute", readApplicationLauncherApplicationLauncherListAttributeInteractionInfo); + Map readApplicationLauncherAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), + readApplicationLauncherAttributeListCommandParams + ); + readApplicationLauncherInteractionInfo.put("readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); + Map readApplicationLauncherClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationLauncherClusterRevisionCommandParams + ); + readApplicationLauncherInteractionInfo.put("readClusterRevisionAttribute", readApplicationLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationLauncher", readApplicationLauncherInteractionInfo); + Map readAudioOutputInteractionInfo = new LinkedHashMap<>(); + Map readAudioOutputAudioOutputListCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputAudioOutputListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readAudioOutputListAttribute( + ( ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAudioOutputListAttributeCallback(), + readAudioOutputAudioOutputListCommandParams + ); + readAudioOutputInteractionInfo.put("readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeInteractionInfo); + Map readAudioOutputCurrentAudioOutputCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputCurrentAudioOutputAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readCurrentAudioOutputAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputCurrentAudioOutputCommandParams + ); + readAudioOutputInteractionInfo.put("readCurrentAudioOutputAttribute", readAudioOutputCurrentAudioOutputAttributeInteractionInfo); + Map readAudioOutputAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readAttributeListAttribute( + ( ChipClusters.AudioOutputCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), + readAudioOutputAttributeListCommandParams + ); + readAudioOutputInteractionInfo.put("readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); + Map readAudioOutputClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputClusterRevisionCommandParams + ); + readAudioOutputInteractionInfo.put("readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("audioOutput", readAudioOutputInteractionInfo); + Map readBarrierControlInteractionInfo = new LinkedHashMap<>(); + Map readBarrierControlBarrierMovingStateCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierMovingStateAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierMovingStateCommandParams + ); + readBarrierControlInteractionInfo.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 + ); + readBarrierControlInteractionInfo.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 + ); + readBarrierControlInteractionInfo.put("readBarrierCapabilitiesAttribute", readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); + Map readBarrierControlBarrierPositionCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readBarrierPositionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierPositionCommandParams + ); + readBarrierControlInteractionInfo.put("readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); + Map readBarrierControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BarrierControlCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBarrierControlClusterAttributeListAttributeCallback(), + readBarrierControlAttributeListCommandParams + ); + readBarrierControlInteractionInfo.put("readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); + Map readBarrierControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlClusterRevisionCommandParams + ); + readBarrierControlInteractionInfo.put("readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("barrierControl", readBarrierControlInteractionInfo); + Map readBasicInteractionInfo = new LinkedHashMap<>(); + Map readBasicInteractionModelVersionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicInteractionModelVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readInteractionModelVersionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInteractionModelVersionCommandParams + ); + readBasicInteractionInfo.put("readInteractionModelVersionAttribute", readBasicInteractionModelVersionAttributeInteractionInfo); + Map readBasicVendorNameCommandParams = new LinkedHashMap(); + InteractionInfo readBasicVendorNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readVendorNameAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicVendorNameCommandParams); - readBasicInteractionInfo.put( - "readVendorNameAttribute", readBasicVendorNameAttributeInteractionInfo); - Map readBasicVendorIDCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicVendorIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readVendorIDAttribute( - (ChipClusters.BasicCluster.VendorIDAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicVendorIDCommandParams); - readBasicInteractionInfo.put( - "readVendorIDAttribute", readBasicVendorIDAttributeInteractionInfo); - Map readBasicProductNameCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicProductNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readProductNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicVendorNameCommandParams + ); + readBasicInteractionInfo.put("readVendorNameAttribute", readBasicVendorNameAttributeInteractionInfo); + Map readBasicVendorIDCommandParams = new LinkedHashMap(); + InteractionInfo readBasicVendorIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readVendorIDAttribute( + ( ChipClusters.BasicCluster.VendorIDAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicVendorIDCommandParams + ); + readBasicInteractionInfo.put("readVendorIDAttribute", readBasicVendorIDAttributeInteractionInfo); + Map readBasicProductNameCommandParams = new LinkedHashMap(); + InteractionInfo readBasicProductNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readProductNameAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductNameCommandParams); - readBasicInteractionInfo.put( - "readProductNameAttribute", readBasicProductNameAttributeInteractionInfo); - Map readBasicProductIDCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicProductIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readProductIDAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicProductIDCommandParams); - readBasicInteractionInfo.put( - "readProductIDAttribute", readBasicProductIDAttributeInteractionInfo); - Map readBasicNodeLabelCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicNodeLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readNodeLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicProductNameCommandParams + ); + readBasicInteractionInfo.put("readProductNameAttribute", readBasicProductNameAttributeInteractionInfo); + Map readBasicProductIDCommandParams = new LinkedHashMap(); + InteractionInfo readBasicProductIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readProductIDAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicProductIDCommandParams + ); + readBasicInteractionInfo.put("readProductIDAttribute", readBasicProductIDAttributeInteractionInfo); + Map readBasicNodeLabelCommandParams = new LinkedHashMap(); + InteractionInfo readBasicNodeLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readNodeLabelAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicNodeLabelCommandParams); - readBasicInteractionInfo.put( - "readNodeLabelAttribute", readBasicNodeLabelAttributeInteractionInfo); - Map readBasicLocationCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicLocationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readLocationAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicNodeLabelCommandParams + ); + readBasicInteractionInfo.put("readNodeLabelAttribute", readBasicNodeLabelAttributeInteractionInfo); + Map readBasicLocationCommandParams = new LinkedHashMap(); + InteractionInfo readBasicLocationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readLocationAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicLocationCommandParams); - readBasicInteractionInfo.put( - "readLocationAttribute", readBasicLocationAttributeInteractionInfo); - Map readBasicHardwareVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicHardwareVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readHardwareVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicHardwareVersionCommandParams); - readBasicInteractionInfo.put( - "readHardwareVersionAttribute", readBasicHardwareVersionAttributeInteractionInfo); - Map readBasicHardwareVersionStringCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicHardwareVersionStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readHardwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicLocationCommandParams + ); + readBasicInteractionInfo.put("readLocationAttribute", readBasicLocationAttributeInteractionInfo); + Map readBasicHardwareVersionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicHardwareVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readHardwareVersionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicHardwareVersionCommandParams + ); + readBasicInteractionInfo.put("readHardwareVersionAttribute", readBasicHardwareVersionAttributeInteractionInfo); + Map readBasicHardwareVersionStringCommandParams = new LinkedHashMap(); + InteractionInfo readBasicHardwareVersionStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readHardwareVersionStringAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicHardwareVersionStringCommandParams); - readBasicInteractionInfo.put( - "readHardwareVersionStringAttribute", - readBasicHardwareVersionStringAttributeInteractionInfo); - Map readBasicSoftwareVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicSoftwareVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readSoftwareVersionAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readBasicHardwareVersionStringCommandParams + ); + readBasicInteractionInfo.put("readHardwareVersionStringAttribute", readBasicHardwareVersionStringAttributeInteractionInfo); + Map readBasicSoftwareVersionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicSoftwareVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readSoftwareVersionAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBasicSoftwareVersionCommandParams); - readBasicInteractionInfo.put( - "readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeInteractionInfo); - Map readBasicSoftwareVersionStringCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicSoftwareVersionStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readSoftwareVersionStringAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicSoftwareVersionCommandParams + ); + readBasicInteractionInfo.put("readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeInteractionInfo); + Map readBasicSoftwareVersionStringCommandParams = new LinkedHashMap(); + InteractionInfo readBasicSoftwareVersionStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readSoftwareVersionStringAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicSoftwareVersionStringCommandParams); - readBasicInteractionInfo.put( - "readSoftwareVersionStringAttribute", - readBasicSoftwareVersionStringAttributeInteractionInfo); - Map readBasicManufacturingDateCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicManufacturingDateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readManufacturingDateAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicSoftwareVersionStringCommandParams + ); + readBasicInteractionInfo.put("readSoftwareVersionStringAttribute", readBasicSoftwareVersionStringAttributeInteractionInfo); + Map readBasicManufacturingDateCommandParams = new LinkedHashMap(); + InteractionInfo readBasicManufacturingDateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readManufacturingDateAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicManufacturingDateCommandParams); - readBasicInteractionInfo.put( - "readManufacturingDateAttribute", readBasicManufacturingDateAttributeInteractionInfo); - Map readBasicPartNumberCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicPartNumberAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readPartNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicManufacturingDateCommandParams + ); + readBasicInteractionInfo.put("readManufacturingDateAttribute", readBasicManufacturingDateAttributeInteractionInfo); + Map readBasicPartNumberCommandParams = new LinkedHashMap(); + InteractionInfo readBasicPartNumberAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readPartNumberAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicPartNumberCommandParams); - readBasicInteractionInfo.put( - "readPartNumberAttribute", readBasicPartNumberAttributeInteractionInfo); - Map readBasicProductURLCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicProductURLAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readProductURLAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicPartNumberCommandParams + ); + readBasicInteractionInfo.put("readPartNumberAttribute", readBasicPartNumberAttributeInteractionInfo); + Map readBasicProductURLCommandParams = new LinkedHashMap(); + InteractionInfo readBasicProductURLAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readProductURLAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductURLCommandParams); - readBasicInteractionInfo.put( - "readProductURLAttribute", readBasicProductURLAttributeInteractionInfo); - Map readBasicProductLabelCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicProductLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readProductLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicProductURLCommandParams + ); + readBasicInteractionInfo.put("readProductURLAttribute", readBasicProductURLAttributeInteractionInfo); + Map readBasicProductLabelCommandParams = new LinkedHashMap(); + InteractionInfo readBasicProductLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readProductLabelAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductLabelCommandParams); - readBasicInteractionInfo.put( - "readProductLabelAttribute", readBasicProductLabelAttributeInteractionInfo); - Map readBasicSerialNumberCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicSerialNumberAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readSerialNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicProductLabelCommandParams + ); + readBasicInteractionInfo.put("readProductLabelAttribute", readBasicProductLabelAttributeInteractionInfo); + Map readBasicSerialNumberCommandParams = new LinkedHashMap(); + InteractionInfo readBasicSerialNumberAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readSerialNumberAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicSerialNumberCommandParams); - readBasicInteractionInfo.put( - "readSerialNumberAttribute", readBasicSerialNumberAttributeInteractionInfo); - Map readBasicLocalConfigDisabledCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicLocalConfigDisabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readLocalConfigDisabledAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readBasicSerialNumberCommandParams + ); + readBasicInteractionInfo.put("readSerialNumberAttribute", readBasicSerialNumberAttributeInteractionInfo); + Map readBasicLocalConfigDisabledCommandParams = new LinkedHashMap(); + InteractionInfo readBasicLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readLocalConfigDisabledAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicLocalConfigDisabledCommandParams); - readBasicInteractionInfo.put( - "readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeInteractionInfo); - Map readBasicReachableCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicReachableAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readReachableAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readBasicLocalConfigDisabledCommandParams + ); + readBasicInteractionInfo.put("readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeInteractionInfo); + Map readBasicReachableCommandParams = new LinkedHashMap(); + InteractionInfo readBasicReachableAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readReachableAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicReachableCommandParams); - readBasicInteractionInfo.put( - "readReachableAttribute", readBasicReachableAttributeInteractionInfo); - Map readBasicUniqueIDCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicUniqueIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readUniqueIDAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBasicReachableCommandParams + ); + readBasicInteractionInfo.put("readReachableAttribute", readBasicReachableAttributeInteractionInfo); + Map readBasicUniqueIDCommandParams = new LinkedHashMap(); + InteractionInfo readBasicUniqueIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readUniqueIDAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicUniqueIDCommandParams); - readBasicInteractionInfo.put( - "readUniqueIDAttribute", readBasicUniqueIDAttributeInteractionInfo); - Map readBasicAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BasicCluster.AttributeListAttributeCallback) callback); - }, + readBasicUniqueIDCommandParams + ); + readBasicInteractionInfo.put("readUniqueIDAttribute", readBasicUniqueIDAttributeInteractionInfo); + Map readBasicAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBasicAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BasicCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBasicClusterAttributeListAttributeCallback(), - readBasicAttributeListCommandParams); - readBasicInteractionInfo.put( - "readAttributeListAttribute", readBasicAttributeListAttributeInteractionInfo); - Map readBasicClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBasicClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicClusterRevisionCommandParams); - readBasicInteractionInfo.put( - "readClusterRevisionAttribute", readBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("basic", readBasicInteractionInfo); - Map readBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map readBinaryInputBasicOutOfServiceCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readOutOfServiceAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readBasicAttributeListCommandParams + ); + readBasicInteractionInfo.put("readAttributeListAttribute", readBasicAttributeListAttributeInteractionInfo); + Map readBasicClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicClusterRevisionCommandParams + ); + readBasicInteractionInfo.put("readClusterRevisionAttribute", readBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("basic", readBasicInteractionInfo); + Map readBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); + Map readBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readOutOfServiceAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicOutOfServiceCommandParams); - readBinaryInputBasicInteractionInfo.put( - "readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); - Map readBinaryInputBasicPresentValueCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readPresentValueAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readBinaryInputBasicOutOfServiceCommandParams + ); + readBinaryInputBasicInteractionInfo.put("readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); + Map readBinaryInputBasicPresentValueCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readPresentValueAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicPresentValueCommandParams); - readBinaryInputBasicInteractionInfo.put( - "readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); - Map readBinaryInputBasicStatusFlagsCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readStatusFlagsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicStatusFlagsCommandParams); - readBinaryInputBasicInteractionInfo.put( - "readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); - Map readBinaryInputBasicAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), - readBinaryInputBasicAttributeListCommandParams); - readBinaryInputBasicInteractionInfo.put( - "readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); - Map readBinaryInputBasicClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicClusterRevisionCommandParams); - readBinaryInputBasicInteractionInfo.put( - "readClusterRevisionAttribute", - readBinaryInputBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("binaryInputBasic", readBinaryInputBasicInteractionInfo); - Map readBindingInteractionInfo = new LinkedHashMap<>(); - Map readBindingAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBindingAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BindingCluster.AttributeListAttributeCallback) callback); - }, + readBinaryInputBasicPresentValueCommandParams + ); + readBinaryInputBasicInteractionInfo.put("readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); + Map readBinaryInputBasicStatusFlagsCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readStatusFlagsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicStatusFlagsCommandParams + ); + readBinaryInputBasicInteractionInfo.put("readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); + Map readBinaryInputBasicAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), + readBinaryInputBasicAttributeListCommandParams + ); + readBinaryInputBasicInteractionInfo.put("readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); + Map readBinaryInputBasicClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicClusterRevisionCommandParams + ); + readBinaryInputBasicInteractionInfo.put("readClusterRevisionAttribute", readBinaryInputBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binaryInputBasic", readBinaryInputBasicInteractionInfo); + Map readBindingInteractionInfo = new LinkedHashMap<>(); + Map readBindingAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBindingAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BindingCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBindingClusterAttributeListAttributeCallback(), - readBindingAttributeListCommandParams); - readBindingInteractionInfo.put( - "readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); - Map readBindingClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBindingClusterRevisionCommandParams); - readBindingInteractionInfo.put( - "readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("binding", readBindingInteractionInfo); - Map readBooleanStateInteractionInfo = new LinkedHashMap<>(); - Map readBooleanStateStateValueCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readStateValueAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readBindingAttributeListCommandParams + ); + readBindingInteractionInfo.put("readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); + Map readBindingClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBindingClusterRevisionCommandParams + ); + readBindingInteractionInfo.put("readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binding", readBindingInteractionInfo); + Map readBooleanStateInteractionInfo = new LinkedHashMap<>(); + Map readBooleanStateStateValueCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readStateValueAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBooleanStateStateValueCommandParams); - readBooleanStateInteractionInfo.put( - "readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); - Map readBooleanStateAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BooleanStateCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), - readBooleanStateAttributeListCommandParams); - readBooleanStateInteractionInfo.put( - "readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); - Map readBooleanStateClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBooleanStateClusterRevisionCommandParams); - readBooleanStateInteractionInfo.put( - "readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("booleanState", readBooleanStateInteractionInfo); - Map readBridgedActionsInteractionInfo = new LinkedHashMap<>(); - Map readBridgedActionsActionListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedActionsActionListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .readActionListAttribute( - (ChipClusters.BridgedActionsCluster.ActionListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedBridgedActionsClusterActionListAttributeCallback(), - readBridgedActionsActionListCommandParams); - readBridgedActionsInteractionInfo.put( - "readActionListAttribute", readBridgedActionsActionListAttributeInteractionInfo); - Map readBridgedActionsEndpointListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedActionsEndpointListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .readEndpointListAttribute( - (ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBridgedActionsClusterEndpointListAttributeCallback(), - readBridgedActionsEndpointListCommandParams); - readBridgedActionsInteractionInfo.put( - "readEndpointListAttribute", readBridgedActionsEndpointListAttributeInteractionInfo); - Map readBridgedActionsSetupUrlCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedActionsSetupUrlAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .readSetupUrlAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readBooleanStateStateValueCommandParams + ); + readBooleanStateInteractionInfo.put("readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); + Map readBooleanStateAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BooleanStateCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), + readBooleanStateAttributeListCommandParams + ); + readBooleanStateInteractionInfo.put("readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); + Map readBooleanStateClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanStateClusterRevisionCommandParams + ); + readBooleanStateInteractionInfo.put("readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("booleanState", readBooleanStateInteractionInfo); + Map readBridgedActionsInteractionInfo = new LinkedHashMap<>(); + Map readBridgedActionsActionListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedActionsActionListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster).readActionListAttribute( + ( ChipClusters.BridgedActionsCluster.ActionListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterActionListAttributeCallback(), + readBridgedActionsActionListCommandParams + ); + readBridgedActionsInteractionInfo.put("readActionListAttribute", readBridgedActionsActionListAttributeInteractionInfo); + Map readBridgedActionsEndpointListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedActionsEndpointListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster).readEndpointListAttribute( + ( ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterEndpointListAttributeCallback(), + readBridgedActionsEndpointListCommandParams + ); + readBridgedActionsInteractionInfo.put("readEndpointListAttribute", readBridgedActionsEndpointListAttributeInteractionInfo); + Map readBridgedActionsSetupUrlCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedActionsSetupUrlAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster).readSetupUrlAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedActionsSetupUrlCommandParams); - readBridgedActionsInteractionInfo.put( - "readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeInteractionInfo); - Map readBridgedActionsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedActionsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BridgedActionsCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBridgedActionsClusterAttributeListAttributeCallback(), - readBridgedActionsAttributeListCommandParams); - readBridgedActionsInteractionInfo.put( - "readAttributeListAttribute", readBridgedActionsAttributeListAttributeInteractionInfo); - Map readBridgedActionsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedActionsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedActionsClusterRevisionCommandParams); - readBridgedActionsInteractionInfo.put( - "readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("bridgedActions", readBridgedActionsInteractionInfo); - Map readBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); - Map readBridgedDeviceBasicAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.BridgedDeviceBasicCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback(), - readBridgedDeviceBasicAttributeListCommandParams); - readBridgedDeviceBasicInteractionInfo.put( - "readAttributeListAttribute", readBridgedDeviceBasicAttributeListAttributeInteractionInfo); - Map readBridgedDeviceBasicClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedDeviceBasicClusterRevisionCommandParams); - readBridgedDeviceBasicInteractionInfo.put( - "readClusterRevisionAttribute", - readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("bridgedDeviceBasic", readBridgedDeviceBasicInteractionInfo); - Map readChannelInteractionInfo = new LinkedHashMap<>(); - Map readChannelChannelListCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelChannelListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readChannelListAttribute( - (ChipClusters.ChannelCluster.ChannelListAttributeCallback) callback); - }, + readBridgedActionsSetupUrlCommandParams + ); + readBridgedActionsInteractionInfo.put("readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeInteractionInfo); + Map readBridgedActionsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedActionsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BridgedActionsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterAttributeListAttributeCallback(), + readBridgedActionsAttributeListCommandParams + ); + readBridgedActionsInteractionInfo.put("readAttributeListAttribute", readBridgedActionsAttributeListAttributeInteractionInfo); + Map readBridgedActionsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedActionsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedActionsClusterRevisionCommandParams + ); + readBridgedActionsInteractionInfo.put("readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedActions", readBridgedActionsInteractionInfo); + Map readBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); + Map readBridgedDeviceBasicAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicCluster) cluster).readAttributeListAttribute( + ( ChipClusters.BridgedDeviceBasicCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback(), + readBridgedDeviceBasicAttributeListCommandParams + ); + readBridgedDeviceBasicInteractionInfo.put("readAttributeListAttribute", readBridgedDeviceBasicAttributeListAttributeInteractionInfo); + Map readBridgedDeviceBasicClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedDeviceBasicClusterRevisionCommandParams + ); + readBridgedDeviceBasicInteractionInfo.put("readClusterRevisionAttribute", readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedDeviceBasic", readBridgedDeviceBasicInteractionInfo); + Map readChannelInteractionInfo = 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); - readChannelInteractionInfo.put( - "readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); - Map readChannelAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ChannelCluster.AttributeListAttributeCallback) callback); - }, + readChannelChannelListCommandParams + ); + readChannelInteractionInfo.put("readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); + Map readChannelAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readChannelAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ChannelCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedChannelClusterAttributeListAttributeCallback(), - readChannelAttributeListCommandParams); - readChannelInteractionInfo.put( - "readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); - Map readChannelClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readChannelClusterRevisionCommandParams); - readChannelInteractionInfo.put( - "readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("channel", readChannelInteractionInfo); - Map readColorControlInteractionInfo = new LinkedHashMap<>(); - Map readColorControlCurrentHueCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCurrentHueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentHueCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readDriftCompensationAttribute", - readColorControlDriftCompensationAttributeInteractionInfo); - Map readColorControlCompensationTextCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCompensationTextAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCompensationTextAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readChannelAttributeListCommandParams + ); + readChannelInteractionInfo.put("readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); + Map readChannelClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChannelClusterRevisionCommandParams + ); + readChannelInteractionInfo.put("readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("channel", readChannelInteractionInfo); + Map readColorControlInteractionInfo = new LinkedHashMap<>(); + Map readColorControlCurrentHueCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readCurrentHueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentHueCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); - Map readColorControlColorTemperatureCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorTemperatureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTemperatureCommandParams); - readColorControlInteractionInfo.put( - "readColorTemperatureAttribute", readColorControlColorTemperatureAttributeInteractionInfo); - Map readColorControlColorModeCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorModeCommandParams); - readColorControlInteractionInfo.put( - "readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); - Map readColorControlColorControlOptionsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorControlOptionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorControlOptionsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorControlOptionsCommandParams); - readColorControlInteractionInfo.put( - "readColorControlOptionsAttribute", - readColorControlColorControlOptionsAttributeInteractionInfo); - Map readColorControlNumberOfPrimariesCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readNumberOfPrimariesAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlNumberOfPrimariesCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); - Map readColorControlPrimary1IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary1IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary1IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); - Map readColorControlPrimary2IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary2IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary2IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); - Map readColorControlPrimary3IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary3IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary3IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); - Map readColorControlPrimary4IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary4IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary4IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); - Map readColorControlPrimary5IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary5IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary5IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); - Map readColorControlPrimary6IntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readPrimary6IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary6IntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); - Map readColorControlColorPointRIntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointRIntensityAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointRIntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); - Map readColorControlColorPointGIntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointGIntensityAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointGIntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); - Map readColorControlColorPointBIntensityCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorPointBIntensityAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointBIntensityCommandParams); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.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); - readColorControlInteractionInfo.put( - "readColorCapabilitiesAttribute", - readColorControlColorCapabilitiesAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMinCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMinAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorTempPhysicalMinAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMinCommandParams); - readColorControlInteractionInfo.put( - "readColorTempPhysicalMinAttribute", - readColorControlColorTempPhysicalMinAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMaxCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMaxAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readColorTempPhysicalMaxAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMaxCommandParams); - readColorControlInteractionInfo.put( - "readColorTempPhysicalMaxAttribute", - readColorControlColorTempPhysicalMaxAttributeInteractionInfo); - Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readCoupleColorTempToLevelMinMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCoupleColorTempToLevelMinMiredsCommandParams); - readColorControlInteractionInfo.put( - "readCoupleColorTempToLevelMinMiredsAttribute", - readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); - Map readColorControlStartUpColorTemperatureMiredsCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readStartUpColorTemperatureMiredsAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlStartUpColorTemperatureMiredsCommandParams); - readColorControlInteractionInfo.put( - "readStartUpColorTemperatureMiredsAttribute", - readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); - Map readColorControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ColorControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), - readColorControlAttributeListCommandParams); - readColorControlInteractionInfo.put( - "readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); - Map readColorControlClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlClusterRevisionCommandParams); - readColorControlInteractionInfo.put( - "readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("colorControl", readColorControlInteractionInfo); - Map readContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map readContentLauncherAcceptHeaderListCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherAcceptHeaderListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readAcceptHeaderListAttribute( - (ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback(), - readContentLauncherAcceptHeaderListCommandParams); - readContentLauncherInteractionInfo.put( - "readAcceptHeaderListAttribute", - readContentLauncherAcceptHeaderListAttributeInteractionInfo); - Map readContentLauncherSupportedStreamingProtocolsCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readSupportedStreamingProtocolsAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readColorControlCompensationTextCommandParams + ); + readColorControlInteractionInfo.put("readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); + Map readColorControlColorTemperatureCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorTemperatureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorTemperatureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTemperatureCommandParams + ); + readColorControlInteractionInfo.put("readColorTemperatureAttribute", readColorControlColorTemperatureAttributeInteractionInfo); + Map readColorControlColorModeCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorModeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorModeCommandParams + ); + readColorControlInteractionInfo.put("readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); + Map readColorControlColorControlOptionsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorControlOptionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorControlOptionsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorControlOptionsCommandParams + ); + readColorControlInteractionInfo.put("readColorControlOptionsAttribute", readColorControlColorControlOptionsAttributeInteractionInfo); + Map readColorControlNumberOfPrimariesCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readNumberOfPrimariesAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlNumberOfPrimariesCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); + Map readColorControlPrimary1IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary1IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary1IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); + Map readColorControlPrimary2IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary2IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary2IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); + Map readColorControlPrimary3IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary3IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary3IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); + Map readColorControlPrimary4IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary4IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary4IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); + Map readColorControlPrimary5IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary5IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary5IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); + Map readColorControlPrimary6IntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readPrimary6IntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary6IntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); + Map readColorControlColorPointRIntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointRIntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointRIntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); + Map readColorControlColorPointGIntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointGIntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointGIntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); + Map readColorControlColorPointBIntensityCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorPointBIntensityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointBIntensityCommandParams + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.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 + ); + readColorControlInteractionInfo.put("readColorCapabilitiesAttribute", readColorControlColorCapabilitiesAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMinCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMinAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMinAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMinCommandParams + ); + readColorControlInteractionInfo.put("readColorTempPhysicalMinAttribute", readColorControlColorTempPhysicalMinAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMaxCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMaxAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMaxAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMaxCommandParams + ); + readColorControlInteractionInfo.put("readColorTempPhysicalMaxAttribute", readColorControlColorTempPhysicalMaxAttributeInteractionInfo); + Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readCoupleColorTempToLevelMinMiredsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCoupleColorTempToLevelMinMiredsCommandParams + ); + readColorControlInteractionInfo.put("readCoupleColorTempToLevelMinMiredsAttribute", readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); + Map readColorControlStartUpColorTemperatureMiredsCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readStartUpColorTemperatureMiredsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlStartUpColorTemperatureMiredsCommandParams + ); + readColorControlInteractionInfo.put("readStartUpColorTemperatureMiredsAttribute", readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); + Map readColorControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ColorControlCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), + readColorControlAttributeListCommandParams + ); + readColorControlInteractionInfo.put("readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); + Map readColorControlClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlClusterRevisionCommandParams + ); + readColorControlInteractionInfo.put("readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("colorControl", readColorControlInteractionInfo); + Map readContentLauncherInteractionInfo = new LinkedHashMap<>(); + Map readContentLauncherAcceptHeaderListCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherAcceptHeaderListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readAcceptHeaderListAttribute( + ( ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback(), + readContentLauncherAcceptHeaderListCommandParams + ); + readContentLauncherInteractionInfo.put("readAcceptHeaderListAttribute", readContentLauncherAcceptHeaderListAttributeInteractionInfo); + Map readContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readSupportedStreamingProtocolsAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readContentLauncherSupportedStreamingProtocolsCommandParams); - readContentLauncherInteractionInfo.put( - "readSupportedStreamingProtocolsAttribute", - readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); - Map readContentLauncherAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedContentLauncherClusterAttributeListAttributeCallback(), - readContentLauncherAttributeListCommandParams); - readContentLauncherInteractionInfo.put( - "readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); - Map readContentLauncherClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readContentLauncherClusterRevisionCommandParams); - readContentLauncherInteractionInfo.put( - "readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("contentLauncher", readContentLauncherInteractionInfo); - Map readDescriptorInteractionInfo = new LinkedHashMap<>(); - Map readDescriptorDeviceListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorDeviceListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readDeviceListAttribute( - (ChipClusters.DescriptorCluster.DeviceListAttributeCallback) callback); - }, + readContentLauncherSupportedStreamingProtocolsCommandParams + ); + readContentLauncherInteractionInfo.put("readSupportedStreamingProtocolsAttribute", readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); + Map readContentLauncherAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAttributeListAttributeCallback(), + readContentLauncherAttributeListCommandParams + ); + readContentLauncherInteractionInfo.put("readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); + Map readContentLauncherClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readContentLauncherClusterRevisionCommandParams + ); + readContentLauncherInteractionInfo.put("readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("contentLauncher", readContentLauncherInteractionInfo); + Map readDescriptorInteractionInfo = new LinkedHashMap<>(); + Map readDescriptorDeviceListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorDeviceListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readDeviceListAttribute( + ( ChipClusters.DescriptorCluster.DeviceListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterDeviceListAttributeCallback(), - readDescriptorDeviceListCommandParams); - readDescriptorInteractionInfo.put( - "readDeviceListAttribute", readDescriptorDeviceListAttributeInteractionInfo); - Map readDescriptorServerListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorServerListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readServerListAttribute( - (ChipClusters.DescriptorCluster.ServerListAttributeCallback) callback); - }, + readDescriptorDeviceListCommandParams + ); + readDescriptorInteractionInfo.put("readDeviceListAttribute", readDescriptorDeviceListAttributeInteractionInfo); + Map readDescriptorServerListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorServerListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readServerListAttribute( + ( ChipClusters.DescriptorCluster.ServerListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterServerListAttributeCallback(), - readDescriptorServerListCommandParams); - readDescriptorInteractionInfo.put( - "readServerListAttribute", readDescriptorServerListAttributeInteractionInfo); - Map readDescriptorClientListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorClientListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readClientListAttribute( - (ChipClusters.DescriptorCluster.ClientListAttributeCallback) callback); - }, + readDescriptorServerListCommandParams + ); + readDescriptorInteractionInfo.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); - readDescriptorInteractionInfo.put( - "readClientListAttribute", readDescriptorClientListAttributeInteractionInfo); - Map readDescriptorPartsListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorPartsListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readPartsListAttribute( - (ChipClusters.DescriptorCluster.PartsListAttributeCallback) callback); - }, + readDescriptorClientListCommandParams + ); + readDescriptorInteractionInfo.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); - readDescriptorInteractionInfo.put( - "readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); - Map readDescriptorAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.DescriptorCluster.AttributeListAttributeCallback) callback); - }, + readDescriptorPartsListCommandParams + ); + readDescriptorInteractionInfo.put("readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); + Map readDescriptorAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readAttributeListAttribute( + ( ChipClusters.DescriptorCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterAttributeListAttributeCallback(), - readDescriptorAttributeListCommandParams); - readDescriptorInteractionInfo.put( - "readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); - Map readDescriptorClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDescriptorClusterRevisionCommandParams); - readDescriptorInteractionInfo.put( - "readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("descriptor", readDescriptorInteractionInfo); - Map readDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); - Map readDiagnosticLogsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), - readDiagnosticLogsAttributeListCommandParams); - readDiagnosticLogsInteractionInfo.put( - "readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); - readAttributeMap.put("diagnosticLogs", readDiagnosticLogsInteractionInfo); - Map readDoorLockInteractionInfo = new LinkedHashMap<>(); - Map readDoorLockLockStateCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockLockStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readLockStateAttribute( - (ChipClusters.DoorLockCluster.LockStateAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockLockStateCommandParams); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.put( - "readLockTypeAttribute", readDoorLockLockTypeAttributeInteractionInfo); - Map readDoorLockActuatorEnabledCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockActuatorEnabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readActuatorEnabledAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readDescriptorAttributeListCommandParams + ); + readDescriptorInteractionInfo.put("readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); + Map readDescriptorClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDescriptorClusterRevisionCommandParams + ); + readDescriptorInteractionInfo.put("readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("descriptor", readDescriptorInteractionInfo); + Map readDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); + Map readDiagnosticLogsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), + readDiagnosticLogsAttributeListCommandParams + ); + readDiagnosticLogsInteractionInfo.put("readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); + readAttributeMap.put("diagnosticLogs", readDiagnosticLogsInteractionInfo); + Map readDoorLockInteractionInfo = new LinkedHashMap<>(); + Map readDoorLockLockStateCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockLockStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readLockStateAttribute( + ( ChipClusters.DoorLockCluster.LockStateAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockLockStateCommandParams + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.put( - "readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); - Map readDoorLockDoorStateCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readDoorStateAttribute( - (ChipClusters.DoorLockCluster.DoorStateAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockDoorStateCommandParams); - readDoorLockInteractionInfo.put( - "readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); - Map readDoorLockNumberOfTotalUsersSupportedCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readNumberOfTotalUsersSupportedAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfTotalUsersSupportedCommandParams); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.put( - "readNumberOfYearDaySchedulesSupportedPerUserAttribute", - readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); - Map readDoorLockMaxPINCodeLengthCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readMaxPINCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMaxPINCodeLengthCommandParams); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.put( - "readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); - Map readDoorLockLanguageCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockLanguageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readLanguageAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readDoorLockActuatorEnabledCommandParams + ); + readDoorLockInteractionInfo.put("readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); + Map readDoorLockDoorStateCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readDoorStateAttribute( + ( ChipClusters.DoorLockCluster.DoorStateAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockDoorStateCommandParams + ); + readDoorLockInteractionInfo.put("readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); + Map readDoorLockNumberOfTotalUsersSupportedCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readNumberOfTotalUsersSupportedAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfTotalUsersSupportedCommandParams + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.put("readNumberOfYearDaySchedulesSupportedPerUserAttribute", readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); + Map readDoorLockMaxPINCodeLengthCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readMaxPINCodeLengthAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMaxPINCodeLengthCommandParams + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.put("readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); + Map readDoorLockLanguageCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockLanguageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readLanguageAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readDoorLockLanguageCommandParams); - readDoorLockInteractionInfo.put( - "readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); - Map readDoorLockAutoRelockTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readAutoRelockTimeAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readDoorLockLanguageCommandParams + ); + readDoorLockInteractionInfo.put("readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); + Map readDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readAutoRelockTimeAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockAutoRelockTimeCommandParams); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.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); - readDoorLockInteractionInfo.put( - "readSupportedOperatingModesAttribute", - readDoorLockSupportedOperatingModesAttributeInteractionInfo); - Map readDoorLockEnableOneTouchLockingCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readEnableOneTouchLockingAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readDoorLockAutoRelockTimeCommandParams + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.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 + ); + readDoorLockInteractionInfo.put("readSupportedOperatingModesAttribute", readDoorLockSupportedOperatingModesAttributeInteractionInfo); + Map readDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readEnableOneTouchLockingAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnableOneTouchLockingCommandParams); - readDoorLockInteractionInfo.put( - "readEnableOneTouchLockingAttribute", - readDoorLockEnableOneTouchLockingAttributeInteractionInfo); - Map readDoorLockEnablePrivacyModeButtonCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readEnablePrivacyModeButtonAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readDoorLockEnableOneTouchLockingCommandParams + ); + readDoorLockInteractionInfo.put("readEnableOneTouchLockingAttribute", readDoorLockEnableOneTouchLockingAttributeInteractionInfo); + Map readDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readEnablePrivacyModeButtonAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnablePrivacyModeButtonCommandParams); - readDoorLockInteractionInfo.put( - "readEnablePrivacyModeButtonAttribute", - readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); - Map readDoorLockWrongCodeEntryLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readWrongCodeEntryLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockWrongCodeEntryLimitCommandParams); - readDoorLockInteractionInfo.put( - "readWrongCodeEntryLimitAttribute", - readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); - Map readDoorLockAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.DoorLockCluster.AttributeListAttributeCallback) callback); - }, + readDoorLockEnablePrivacyModeButtonCommandParams + ); + readDoorLockInteractionInfo.put("readEnablePrivacyModeButtonAttribute", readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); + Map readDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readWrongCodeEntryLimitAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockWrongCodeEntryLimitCommandParams + ); + readDoorLockInteractionInfo.put("readWrongCodeEntryLimitAttribute", readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); + Map readDoorLockAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readAttributeListAttribute( + ( ChipClusters.DoorLockCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDoorLockClusterAttributeListAttributeCallback(), - readDoorLockAttributeListCommandParams); - readDoorLockInteractionInfo.put( - "readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); - Map readDoorLockClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockClusterRevisionCommandParams); - readDoorLockInteractionInfo.put( - "readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("doorLock", readDoorLockInteractionInfo); - Map readElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readElectricalMeasurementMeasurementTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readMeasurementTypeAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readDoorLockAttributeListCommandParams + ); + readDoorLockInteractionInfo.put("readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); + Map readDoorLockClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockClusterRevisionCommandParams + ); + readDoorLockInteractionInfo.put("readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("doorLock", readDoorLockInteractionInfo); + Map readElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readElectricalMeasurementMeasurementTypeCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasurementTypeAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementMeasurementTypeCommandParams); - readElectricalMeasurementInteractionInfo.put( - "readMeasurementTypeAttribute", - readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); - Map readElectricalMeasurementTotalActivePowerCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readTotalActivePowerAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readElectricalMeasurementMeasurementTypeCommandParams + ); + readElectricalMeasurementInteractionInfo.put("readMeasurementTypeAttribute", readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); + Map readElectricalMeasurementTotalActivePowerCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readTotalActivePowerAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementTotalActivePowerCommandParams); - readElectricalMeasurementInteractionInfo.put( - "readTotalActivePowerAttribute", - readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readRmsVoltageAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageCommandParams); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.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); - readElectricalMeasurementInteractionInfo.put( - "readActivePowerMaxAttribute", - readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); - Map readElectricalMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), - readElectricalMeasurementAttributeListCommandParams); - readElectricalMeasurementInteractionInfo.put( - "readAttributeListAttribute", - readElectricalMeasurementAttributeListAttributeInteractionInfo); - Map readElectricalMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementClusterRevisionCommandParams); - readElectricalMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", - readElectricalMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("electricalMeasurement", readElectricalMeasurementInteractionInfo); - Map readEthernetNetworkDiagnosticsInteractionInfo = - new LinkedHashMap<>(); - Map readEthernetNetworkDiagnosticsPHYRateCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readPHYRateAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readEthernetNetworkDiagnosticsPHYRateCommandParams); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readFullDuplexAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readElectricalMeasurementTotalActivePowerCommandParams + ); + readElectricalMeasurementInteractionInfo.put("readTotalActivePowerAttribute", readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageCommandParams + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.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 + ); + readElectricalMeasurementInteractionInfo.put("readActivePowerMaxAttribute", readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); + Map readElectricalMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), + readElectricalMeasurementAttributeListCommandParams + ); + readElectricalMeasurementInteractionInfo.put("readAttributeListAttribute", readElectricalMeasurementAttributeListAttributeInteractionInfo); + Map readElectricalMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementClusterRevisionCommandParams + ); + readElectricalMeasurementInteractionInfo.put("readClusterRevisionAttribute", readElectricalMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("electricalMeasurement", readElectricalMeasurementInteractionInfo); + Map readEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + Map readEthernetNetworkDiagnosticsPHYRateCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPHYRateAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthernetNetworkDiagnosticsPHYRateCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.put("readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFullDuplexAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readEthernetNetworkDiagnosticsFullDuplexCommandParams); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readFullDuplexAttribute", - readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readPacketRxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsFullDuplexCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readPacketRxCountAttribute", - readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketTxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readPacketTxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsPacketRxCountCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readPacketTxCountAttribute", - readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTxErrCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readTxErrCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsPacketTxCountCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readTxErrCountAttribute", - readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCollisionCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readCollisionCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsTxErrCountCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readCollisionCountAttribute", - readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsOverrunCountCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsCollisionCountCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readOverrunCountAttribute", - readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readCarrierDetectAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsOverrunCountCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCarrierDetectAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readEthernetNetworkDiagnosticsCarrierDetectCommandParams); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readCarrierDetectAttribute", - readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTimeSinceResetCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readTimeSinceResetAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsCarrierDetectCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readTimeSinceResetAttribute", - readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.EthernetNetworkDiagnosticsCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readEthernetNetworkDiagnosticsAttributeListCommandParams); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readAttributeListAttribute", - readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsTimeSinceResetCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.put("readTimeSinceResetAttribute", readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.EthernetNetworkDiagnosticsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readEthernetNetworkDiagnosticsAttributeListCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.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); - readEthernetNetworkDiagnosticsInteractionInfo.put( - "readClusterRevisionAttribute", - readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo); - Map readFixedLabelInteractionInfo = new LinkedHashMap<>(); - Map readFixedLabelLabelListCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelLabelListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readLabelListAttribute( - (ChipClusters.FixedLabelCluster.LabelListAttributeCallback) callback); - }, + readEthernetNetworkDiagnosticsFeatureMapCommandParams + ); + readEthernetNetworkDiagnosticsInteractionInfo.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 + ); + readEthernetNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo); + Map readFixedLabelInteractionInfo = 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); - readFixedLabelInteractionInfo.put( - "readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); - Map readFixedLabelAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.FixedLabelCluster.AttributeListAttributeCallback) callback); - }, + readFixedLabelLabelListCommandParams + ); + readFixedLabelInteractionInfo.put("readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); + Map readFixedLabelAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster).readAttributeListAttribute( + ( ChipClusters.FixedLabelCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedFixedLabelClusterAttributeListAttributeCallback(), - readFixedLabelAttributeListCommandParams); - readFixedLabelInteractionInfo.put( - "readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); - Map readFixedLabelClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFixedLabelClusterRevisionCommandParams); - readFixedLabelInteractionInfo.put( - "readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("fixedLabel", readFixedLabelInteractionInfo); - Map readFlowMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readFlowMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMeasuredValueCommandParams); - readFlowMeasurementInteractionInfo.put( - "readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMinMeasuredValueCommandParams); - readFlowMeasurementInteractionInfo.put( - "readMinMeasuredValueAttribute", - readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMaxMeasuredValueCommandParams); - readFlowMeasurementInteractionInfo.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); - readFlowMeasurementInteractionInfo.put( - "readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); - Map readFlowMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), - readFlowMeasurementAttributeListCommandParams); - readFlowMeasurementInteractionInfo.put( - "readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); - Map readFlowMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementClusterRevisionCommandParams); - readFlowMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("flowMeasurement", readFlowMeasurementInteractionInfo); - Map readGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readGeneralCommissioningBreadcrumbCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readBreadcrumbAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readFixedLabelAttributeListCommandParams + ); + readFixedLabelInteractionInfo.put("readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); + Map readFixedLabelClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFixedLabelClusterRevisionCommandParams + ); + readFixedLabelInteractionInfo.put("readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("fixedLabel", readFixedLabelInteractionInfo); + Map readFlowMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readFlowMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMeasuredValueCommandParams + ); + readFlowMeasurementInteractionInfo.put("readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readMinMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMinMeasuredValueCommandParams + ); + readFlowMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMaxMeasuredValueCommandParams + ); + readFlowMeasurementInteractionInfo.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 + ); + readFlowMeasurementInteractionInfo.put("readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); + Map readFlowMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), + readFlowMeasurementAttributeListCommandParams + ); + readFlowMeasurementInteractionInfo.put("readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); + Map readFlowMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementClusterRevisionCommandParams + ); + readFlowMeasurementInteractionInfo.put("readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("flowMeasurement", readFlowMeasurementInteractionInfo); + Map readGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readBreadcrumbAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralCommissioningBreadcrumbCommandParams); - readGeneralCommissioningInteractionInfo.put( - "readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); - Map - readGeneralCommissioningBasicCommissioningInfoListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readBasicCommissioningInfoListAttribute( - (ChipClusters.GeneralCommissioningCluster - .BasicCommissioningInfoListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback(), - readGeneralCommissioningBasicCommissioningInfoListCommandParams); - readGeneralCommissioningInteractionInfo.put( - "readBasicCommissioningInfoListAttribute", - readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo); - Map readGeneralCommissioningRegulatoryConfigCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readRegulatoryConfigAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningRegulatoryConfigCommandParams); - readGeneralCommissioningInteractionInfo.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); - readGeneralCommissioningInteractionInfo.put( - "readLocationCapabilityAttribute", - readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); - Map readGeneralCommissioningAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), - readGeneralCommissioningAttributeListCommandParams); - readGeneralCommissioningInteractionInfo.put( - "readAttributeListAttribute", - readGeneralCommissioningAttributeListAttributeInteractionInfo); - Map readGeneralCommissioningClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningClusterRevisionCommandParams); - readGeneralCommissioningInteractionInfo.put( - "readClusterRevisionAttribute", - readGeneralCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("generalCommissioning", readGeneralCommissioningInteractionInfo); - Map readGeneralDiagnosticsInteractionInfo = 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); - readGeneralDiagnosticsInteractionInfo.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); - readGeneralDiagnosticsInteractionInfo.put( - "readRebootCountAttribute", readGeneralDiagnosticsRebootCountAttributeInteractionInfo); - Map readGeneralDiagnosticsUpTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsUpTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readUpTimeAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readGeneralCommissioningBreadcrumbCommandParams + ); + readGeneralCommissioningInteractionInfo.put("readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); + Map readGeneralCommissioningBasicCommissioningInfoListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readBasicCommissioningInfoListAttribute( + ( ChipClusters.GeneralCommissioningCluster.BasicCommissioningInfoListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback(), + readGeneralCommissioningBasicCommissioningInfoListCommandParams + ); + readGeneralCommissioningInteractionInfo.put("readBasicCommissioningInfoListAttribute", readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo); + Map readGeneralCommissioningRegulatoryConfigCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readRegulatoryConfigAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningRegulatoryConfigCommandParams + ); + readGeneralCommissioningInteractionInfo.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 + ); + readGeneralCommissioningInteractionInfo.put("readLocationCapabilityAttribute", readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); + Map readGeneralCommissioningAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readAttributeListAttribute( + ( ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), + readGeneralCommissioningAttributeListCommandParams + ); + readGeneralCommissioningInteractionInfo.put("readAttributeListAttribute", readGeneralCommissioningAttributeListAttributeInteractionInfo); + Map readGeneralCommissioningClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningClusterRevisionCommandParams + ); + readGeneralCommissioningInteractionInfo.put("readClusterRevisionAttribute", readGeneralCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalCommissioning", readGeneralCommissioningInteractionInfo); + Map readGeneralDiagnosticsInteractionInfo = 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 + ); + readGeneralDiagnosticsInteractionInfo.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 + ); + readGeneralDiagnosticsInteractionInfo.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); - readGeneralDiagnosticsInteractionInfo.put( - "readUpTimeAttribute", readGeneralDiagnosticsUpTimeAttributeInteractionInfo); - Map readGeneralDiagnosticsTotalOperationalHoursCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readTotalOperationalHoursAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readGeneralDiagnosticsUpTimeCommandParams + ); + readGeneralDiagnosticsInteractionInfo.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); - readGeneralDiagnosticsInteractionInfo.put( - "readTotalOperationalHoursAttribute", - readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); - Map readGeneralDiagnosticsBootReasonsCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsBootReasonsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readBootReasonsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsBootReasonsCommandParams); - readGeneralDiagnosticsInteractionInfo.put( - "readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeInteractionInfo); - Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readActiveHardwareFaultsAttribute( - (ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), - readGeneralDiagnosticsActiveHardwareFaultsCommandParams); - readGeneralDiagnosticsInteractionInfo.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); - readGeneralDiagnosticsInteractionInfo.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); - readGeneralDiagnosticsInteractionInfo.put( - "readActiveNetworkFaultsAttribute", - readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); - Map readGeneralDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), - readGeneralDiagnosticsAttributeListCommandParams); - readGeneralDiagnosticsInteractionInfo.put( - "readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); - Map readGeneralDiagnosticsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsClusterRevisionCommandParams); - readGeneralDiagnosticsInteractionInfo.put( - "readClusterRevisionAttribute", - readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo); - Map readGroupKeyManagementInteractionInfo = 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); - readGroupKeyManagementInteractionInfo.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); - readGroupKeyManagementInteractionInfo.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); - readGroupKeyManagementInteractionInfo.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); - readGroupKeyManagementInteractionInfo.put( - "readMaxGroupKeysPerFabricAttribute", - readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); - Map readGroupKeyManagementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), - readGroupKeyManagementAttributeListCommandParams); - readGroupKeyManagementInteractionInfo.put( - "readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); - Map readGroupKeyManagementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupKeyManagementClusterRevisionCommandParams); - readGroupKeyManagementInteractionInfo.put( - "readClusterRevisionAttribute", - readGroupKeyManagementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("groupKeyManagement", readGroupKeyManagementInteractionInfo); - Map readGroupsInteractionInfo = new LinkedHashMap<>(); - Map readGroupsNameSupportCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsNameSupportAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readNameSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsNameSupportCommandParams); - readGroupsInteractionInfo.put( - "readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); - Map readGroupsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.GroupsCluster.AttributeListAttributeCallback) callback); - }, + readGeneralDiagnosticsTotalOperationalHoursCommandParams + ); + readGeneralDiagnosticsInteractionInfo.put("readTotalOperationalHoursAttribute", readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); + Map readGeneralDiagnosticsBootReasonsCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsBootReasonsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readBootReasonsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsBootReasonsCommandParams + ); + readGeneralDiagnosticsInteractionInfo.put("readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeInteractionInfo); + Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readActiveHardwareFaultsAttribute( + ( ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), + readGeneralDiagnosticsActiveHardwareFaultsCommandParams + ); + readGeneralDiagnosticsInteractionInfo.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 + ); + readGeneralDiagnosticsInteractionInfo.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 + ); + readGeneralDiagnosticsInteractionInfo.put("readActiveNetworkFaultsAttribute", readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); + Map readGeneralDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), + readGeneralDiagnosticsAttributeListCommandParams + ); + readGeneralDiagnosticsInteractionInfo.put("readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); + Map readGeneralDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsClusterRevisionCommandParams + ); + readGeneralDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo); + Map readGroupKeyManagementInteractionInfo = 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 + ); + readGroupKeyManagementInteractionInfo.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 + ); + readGroupKeyManagementInteractionInfo.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 + ); + readGroupKeyManagementInteractionInfo.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 + ); + readGroupKeyManagementInteractionInfo.put("readMaxGroupKeysPerFabricAttribute", readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); + Map readGroupKeyManagementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), + readGroupKeyManagementAttributeListCommandParams + ); + readGroupKeyManagementInteractionInfo.put("readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); + Map readGroupKeyManagementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupKeyManagementClusterRevisionCommandParams + ); + readGroupKeyManagementInteractionInfo.put("readClusterRevisionAttribute", readGroupKeyManagementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groupKeyManagement", readGroupKeyManagementInteractionInfo); + Map readGroupsInteractionInfo = new LinkedHashMap<>(); + Map readGroupsNameSupportCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsNameSupportAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readNameSupportAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsNameSupportCommandParams + ); + readGroupsInteractionInfo.put("readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); + Map readGroupsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.GroupsCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedGroupsClusterAttributeListAttributeCallback(), - readGroupsAttributeListCommandParams); - readGroupsInteractionInfo.put( - "readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); - Map readGroupsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsClusterRevisionCommandParams); - readGroupsInteractionInfo.put( - "readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("groups", readGroupsInteractionInfo); - Map readIdentifyInteractionInfo = new LinkedHashMap<>(); - Map readIdentifyIdentifyTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readIdentifyTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyIdentifyTimeCommandParams); - readIdentifyInteractionInfo.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); - readIdentifyInteractionInfo.put( - "readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); - Map readIdentifyAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.IdentifyCluster.AttributeListAttributeCallback) callback); - }, + readGroupsAttributeListCommandParams + ); + readGroupsInteractionInfo.put("readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); + Map readGroupsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsClusterRevisionCommandParams + ); + readGroupsInteractionInfo.put("readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groups", readGroupsInteractionInfo); + Map readIdentifyInteractionInfo = new LinkedHashMap<>(); + Map readIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readIdentifyTimeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyIdentifyTimeCommandParams + ); + readIdentifyInteractionInfo.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 + ); + readIdentifyInteractionInfo.put("readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); + Map readIdentifyAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readAttributeListAttribute( + ( ChipClusters.IdentifyCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedIdentifyClusterAttributeListAttributeCallback(), - readIdentifyAttributeListCommandParams); - readIdentifyInteractionInfo.put( - "readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); - Map readIdentifyClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyClusterRevisionCommandParams); - readIdentifyInteractionInfo.put( - "readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("identify", readIdentifyInteractionInfo); - Map readIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readIlluminanceMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMeasuredValueCommandParams); - readIlluminanceMeasurementInteractionInfo.put( - "readMeasuredValueAttribute", - readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readMinMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMinMeasuredValueCommandParams); - readIlluminanceMeasurementInteractionInfo.put( - "readMinMeasuredValueAttribute", - readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute( - (ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMaxMeasuredValueCommandParams); - readIlluminanceMeasurementInteractionInfo.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); - readIlluminanceMeasurementInteractionInfo.put( - "readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); - Map readIlluminanceMeasurementLightSensorTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readLightSensorTypeAttribute( - (ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementLightSensorTypeCommandParams); - readIlluminanceMeasurementInteractionInfo.put( - "readLightSensorTypeAttribute", - readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); - Map readIlluminanceMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), - readIlluminanceMeasurementAttributeListCommandParams); - readIlluminanceMeasurementInteractionInfo.put( - "readAttributeListAttribute", - readIlluminanceMeasurementAttributeListAttributeInteractionInfo); - Map readIlluminanceMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementClusterRevisionCommandParams); - readIlluminanceMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", - readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo); - Map readKeypadInputInteractionInfo = new LinkedHashMap<>(); - Map readKeypadInputAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.KeypadInputCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), - readKeypadInputAttributeListCommandParams); - readKeypadInputInteractionInfo.put( - "readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); - Map readKeypadInputClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readKeypadInputClusterRevisionCommandParams); - readKeypadInputInteractionInfo.put( - "readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("keypadInput", readKeypadInputInteractionInfo); - Map readLevelControlInteractionInfo = new LinkedHashMap<>(); - Map readLevelControlCurrentLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readCurrentLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlCurrentLevelCommandParams); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.put( - "readOnOffTransitionTimeAttribute", - readLevelControlOnOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlOnLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readOnLevelAttribute( - (ChipClusters.LevelControlCluster.OnLevelAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnLevelCommandParams); - readLevelControlInteractionInfo.put( - "readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); - Map readLevelControlOnTransitionTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readOnTransitionTimeAttribute( - (ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnTransitionTimeCommandParams); - readLevelControlInteractionInfo.put( - "readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); - Map readLevelControlOffTransitionTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readOffTransitionTimeAttribute( - (ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOffTransitionTimeCommandParams); - readLevelControlInteractionInfo.put( - "readOffTransitionTimeAttribute", - readLevelControlOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlDefaultMoveRateCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readDefaultMoveRateAttribute( - (ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlDefaultMoveRateCommandParams); - readLevelControlInteractionInfo.put( - "readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); - Map readLevelControlStartUpCurrentLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readStartUpCurrentLevelAttribute( - (ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlStartUpCurrentLevelCommandParams); - readLevelControlInteractionInfo.put( - "readStartUpCurrentLevelAttribute", - readLevelControlStartUpCurrentLevelAttributeInteractionInfo); - Map readLevelControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.LevelControlCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), - readLevelControlAttributeListCommandParams); - readLevelControlInteractionInfo.put( - "readAttributeListAttribute", readLevelControlAttributeListAttributeInteractionInfo); - Map readLevelControlFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readLevelControlFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readIdentifyAttributeListCommandParams + ); + readIdentifyInteractionInfo.put("readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); + Map readIdentifyClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyClusterRevisionCommandParams + ); + readIdentifyInteractionInfo.put("readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("identify", readIdentifyInteractionInfo); + Map readIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readIlluminanceMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMeasuredValueAttribute( + ( ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMeasuredValueCommandParams + ); + readIlluminanceMeasurementInteractionInfo.put("readMeasuredValueAttribute", readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMinMeasuredValueAttribute( + ( ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMinMeasuredValueCommandParams + ); + readIlluminanceMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + ( ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMaxMeasuredValueCommandParams + ); + readIlluminanceMeasurementInteractionInfo.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 + ); + readIlluminanceMeasurementInteractionInfo.put("readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); + Map readIlluminanceMeasurementLightSensorTypeCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readLightSensorTypeAttribute( + ( ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementLightSensorTypeCommandParams + ); + readIlluminanceMeasurementInteractionInfo.put("readLightSensorTypeAttribute", readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); + Map readIlluminanceMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), + readIlluminanceMeasurementAttributeListCommandParams + ); + readIlluminanceMeasurementInteractionInfo.put("readAttributeListAttribute", readIlluminanceMeasurementAttributeListAttributeInteractionInfo); + Map readIlluminanceMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementClusterRevisionCommandParams + ); + readIlluminanceMeasurementInteractionInfo.put("readClusterRevisionAttribute", readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo); + Map readKeypadInputInteractionInfo = new LinkedHashMap<>(); + Map readKeypadInputAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster).readAttributeListAttribute( + ( ChipClusters.KeypadInputCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), + readKeypadInputAttributeListCommandParams + ); + readKeypadInputInteractionInfo.put("readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); + Map readKeypadInputClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readKeypadInputClusterRevisionCommandParams + ); + readKeypadInputInteractionInfo.put("readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("keypadInput", readKeypadInputInteractionInfo); + Map readLevelControlInteractionInfo = new LinkedHashMap<>(); + Map readLevelControlCurrentLevelCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readCurrentLevelAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlCurrentLevelCommandParams + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.put("readOnOffTransitionTimeAttribute", readLevelControlOnOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlOnLevelCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readOnLevelAttribute( + ( ChipClusters.LevelControlCluster.OnLevelAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnLevelCommandParams + ); + readLevelControlInteractionInfo.put("readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); + Map readLevelControlOnTransitionTimeCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readOnTransitionTimeAttribute( + ( ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnTransitionTimeCommandParams + ); + readLevelControlInteractionInfo.put("readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); + Map readLevelControlOffTransitionTimeCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readOffTransitionTimeAttribute( + ( ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOffTransitionTimeCommandParams + ); + readLevelControlInteractionInfo.put("readOffTransitionTimeAttribute", readLevelControlOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlDefaultMoveRateCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readDefaultMoveRateAttribute( + ( ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlDefaultMoveRateCommandParams + ); + readLevelControlInteractionInfo.put("readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); + Map readLevelControlStartUpCurrentLevelCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readStartUpCurrentLevelAttribute( + ( ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlStartUpCurrentLevelCommandParams + ); + readLevelControlInteractionInfo.put("readStartUpCurrentLevelAttribute", readLevelControlStartUpCurrentLevelAttributeInteractionInfo); + Map readLevelControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster).readAttributeListAttribute( + ( ChipClusters.LevelControlCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), + readLevelControlAttributeListCommandParams + ); + readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.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); - readLevelControlInteractionInfo.put( - "readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("levelControl", readLevelControlInteractionInfo); - Map readLocalizationConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map readLocalizationConfigurationActiveLocaleCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readActiveLocaleAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readLevelControlFeatureMapCommandParams + ); + readLevelControlInteractionInfo.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 + ); + readLevelControlInteractionInfo.put("readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("levelControl", readLevelControlInteractionInfo); + Map readLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); + Map readLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readActiveLocaleAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readLocalizationConfigurationActiveLocaleCommandParams); - readLocalizationConfigurationInteractionInfo.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); - readLocalizationConfigurationInteractionInfo.put( - "readSupportedLocalesAttribute", - readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); - Map readLocalizationConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLocalizationConfigurationClusterRevisionCommandParams); - readLocalizationConfigurationInteractionInfo.put( - "readClusterRevisionAttribute", - readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("localizationConfiguration", readLocalizationConfigurationInteractionInfo); - Map readLowPowerInteractionInfo = new LinkedHashMap<>(); - Map readLowPowerAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.LowPowerCluster.AttributeListAttributeCallback) callback); - }, + readLocalizationConfigurationActiveLocaleCommandParams + ); + readLocalizationConfigurationInteractionInfo.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 + ); + readLocalizationConfigurationInteractionInfo.put("readSupportedLocalesAttribute", readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); + Map readLocalizationConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLocalizationConfigurationClusterRevisionCommandParams + ); + readLocalizationConfigurationInteractionInfo.put("readClusterRevisionAttribute", readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("localizationConfiguration", readLocalizationConfigurationInteractionInfo); + Map readLowPowerInteractionInfo = new LinkedHashMap<>(); + Map readLowPowerAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).readAttributeListAttribute( + ( ChipClusters.LowPowerCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLowPowerClusterAttributeListAttributeCallback(), - readLowPowerAttributeListCommandParams); - readLowPowerInteractionInfo.put( - "readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); - Map readLowPowerClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLowPowerClusterRevisionCommandParams); - readLowPowerInteractionInfo.put( - "readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("lowPower", readLowPowerInteractionInfo); - Map readMediaInputInteractionInfo = new LinkedHashMap<>(); - Map readMediaInputMediaInputListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputMediaInputListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readMediaInputListAttribute( - (ChipClusters.MediaInputCluster.MediaInputListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedMediaInputClusterMediaInputListAttributeCallback(), - readMediaInputMediaInputListCommandParams); - readMediaInputInteractionInfo.put( - "readMediaInputListAttribute", readMediaInputMediaInputListAttributeInteractionInfo); - Map readMediaInputCurrentMediaInputCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputCurrentMediaInputAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readCurrentMediaInputAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputCurrentMediaInputCommandParams); - readMediaInputInteractionInfo.put( - "readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeInteractionInfo); - Map readMediaInputAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.MediaInputCluster.AttributeListAttributeCallback) callback); - }, + readLowPowerAttributeListCommandParams + ); + readLowPowerInteractionInfo.put("readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); + Map readLowPowerClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLowPowerClusterRevisionCommandParams + ); + readLowPowerInteractionInfo.put("readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("lowPower", readLowPowerInteractionInfo); + Map readMediaInputInteractionInfo = new LinkedHashMap<>(); + Map readMediaInputMediaInputListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputMediaInputListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readMediaInputListAttribute( + ( ChipClusters.MediaInputCluster.MediaInputListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaInputClusterMediaInputListAttributeCallback(), + readMediaInputMediaInputListCommandParams + ); + readMediaInputInteractionInfo.put("readMediaInputListAttribute", readMediaInputMediaInputListAttributeInteractionInfo); + Map readMediaInputCurrentMediaInputCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputCurrentMediaInputAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readCurrentMediaInputAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputCurrentMediaInputCommandParams + ); + readMediaInputInteractionInfo.put("readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeInteractionInfo); + Map readMediaInputAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readAttributeListAttribute( + ( ChipClusters.MediaInputCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedMediaInputClusterAttributeListAttributeCallback(), - readMediaInputAttributeListCommandParams); - readMediaInputInteractionInfo.put( - "readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); - Map readMediaInputClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputClusterRevisionCommandParams); - readMediaInputInteractionInfo.put( - "readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("mediaInput", readMediaInputInteractionInfo); - Map readMediaPlaybackInteractionInfo = new LinkedHashMap<>(); - Map readMediaPlaybackPlaybackStateCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readPlaybackStateAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackPlaybackStateCommandParams); - readMediaPlaybackInteractionInfo.put( - "readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeInteractionInfo); - Map readMediaPlaybackStartTimeCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readStartTimeAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readMediaInputAttributeListCommandParams + ); + readMediaInputInteractionInfo.put("readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); + Map readMediaInputClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputClusterRevisionCommandParams + ); + readMediaInputInteractionInfo.put("readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaInput", readMediaInputInteractionInfo); + Map readMediaPlaybackInteractionInfo = new LinkedHashMap<>(); + Map readMediaPlaybackPlaybackStateCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackPlaybackStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readPlaybackStateAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackPlaybackStateCommandParams + ); + readMediaPlaybackInteractionInfo.put("readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeInteractionInfo); + Map readMediaPlaybackStartTimeCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readStartTimeAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackStartTimeCommandParams); - readMediaPlaybackInteractionInfo.put( - "readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); - Map readMediaPlaybackDurationCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readDurationAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readMediaPlaybackStartTimeCommandParams + ); + readMediaPlaybackInteractionInfo.put("readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); + Map readMediaPlaybackDurationCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readDurationAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackDurationCommandParams); - readMediaPlaybackInteractionInfo.put( - "readDurationAttribute", readMediaPlaybackDurationAttributeInteractionInfo); - Map readMediaPlaybackPlaybackSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readPlaybackSpeedAttribute((ChipClusters.FloatAttributeCallback) callback); - }, + readMediaPlaybackDurationCommandParams + ); + readMediaPlaybackInteractionInfo.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); - readMediaPlaybackInteractionInfo.put( - "readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeEndCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readSeekRangeEndAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readMediaPlaybackPlaybackSpeedCommandParams + ); + readMediaPlaybackInteractionInfo.put("readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeEndCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeEndAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackSeekRangeEndCommandParams); - readMediaPlaybackInteractionInfo.put( - "readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeStartCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readSeekRangeStartAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readMediaPlaybackSeekRangeEndCommandParams + ); + readMediaPlaybackInteractionInfo.put("readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeStartCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeStartAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackSeekRangeStartCommandParams); - readMediaPlaybackInteractionInfo.put( - "readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); - Map readMediaPlaybackAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), - readMediaPlaybackAttributeListCommandParams); - readMediaPlaybackInteractionInfo.put( - "readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); - Map readMediaPlaybackClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackClusterRevisionCommandParams); - readMediaPlaybackInteractionInfo.put( - "readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("mediaPlayback", readMediaPlaybackInteractionInfo); - Map readModeSelectInteractionInfo = new LinkedHashMap<>(); - Map readModeSelectCurrentModeCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readCurrentModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectCurrentModeCommandParams); - readModeSelectInteractionInfo.put( - "readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); - Map readModeSelectSupportedModesCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readSupportedModesAttribute( - (ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), - readModeSelectSupportedModesCommandParams); - readModeSelectInteractionInfo.put( - "readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); - Map readModeSelectOnModeCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectOnModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readOnModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectOnModeCommandParams); - readModeSelectInteractionInfo.put( - "readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); - Map readModeSelectStartUpModeCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readStartUpModeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectStartUpModeCommandParams); - readModeSelectInteractionInfo.put( - "readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); - Map readModeSelectDescriptionCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readMediaPlaybackSeekRangeStartCommandParams + ); + readMediaPlaybackInteractionInfo.put("readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); + Map readMediaPlaybackAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readAttributeListAttribute( + ( ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), + readMediaPlaybackAttributeListCommandParams + ); + readMediaPlaybackInteractionInfo.put("readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); + Map readMediaPlaybackClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackClusterRevisionCommandParams + ); + readMediaPlaybackInteractionInfo.put("readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaPlayback", readMediaPlaybackInteractionInfo); + Map readModeSelectInteractionInfo = new LinkedHashMap<>(); + Map readModeSelectCurrentModeCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readCurrentModeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectCurrentModeCommandParams + ); + readModeSelectInteractionInfo.put("readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); + Map readModeSelectSupportedModesCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readSupportedModesAttribute( + ( ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), + readModeSelectSupportedModesCommandParams + ); + readModeSelectInteractionInfo.put("readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); + Map readModeSelectOnModeCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectOnModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readOnModeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectOnModeCommandParams + ); + readModeSelectInteractionInfo.put("readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); + Map readModeSelectStartUpModeCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readStartUpModeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectStartUpModeCommandParams + ); + readModeSelectInteractionInfo.put("readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); + Map readModeSelectDescriptionCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readDescriptionAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readModeSelectDescriptionCommandParams); - readModeSelectInteractionInfo.put( - "readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); - Map readModeSelectAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ModeSelectCluster.AttributeListAttributeCallback) callback); - }, + readModeSelectDescriptionCommandParams + ); + readModeSelectInteractionInfo.put("readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); + Map readModeSelectAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ModeSelectCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedModeSelectClusterAttributeListAttributeCallback(), - readModeSelectAttributeListCommandParams); - readModeSelectInteractionInfo.put( - "readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); - Map readModeSelectClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectClusterRevisionCommandParams); - readModeSelectInteractionInfo.put( - "readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("modeSelect", readModeSelectInteractionInfo); - Map readNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readNetworkCommissioningMaxNetworksCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readMaxNetworksAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningMaxNetworksCommandParams); - readNetworkCommissioningInteractionInfo.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); - readNetworkCommissioningInteractionInfo.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); - readNetworkCommissioningInteractionInfo.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); - readNetworkCommissioningInteractionInfo.put( - "readConnectMaxTimeSecondsAttribute", - readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo); - Map readNetworkCommissioningInterfaceEnabledCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readInterfaceEnabledAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readModeSelectAttributeListCommandParams + ); + readModeSelectInteractionInfo.put("readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); + Map readModeSelectClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectClusterRevisionCommandParams + ); + readModeSelectInteractionInfo.put("readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("modeSelect", readModeSelectInteractionInfo); + Map readNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readNetworkCommissioningMaxNetworksCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readMaxNetworksAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningMaxNetworksCommandParams + ); + readNetworkCommissioningInteractionInfo.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 + ); + readNetworkCommissioningInteractionInfo.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 + ); + readNetworkCommissioningInteractionInfo.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 + ); + readNetworkCommissioningInteractionInfo.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); - readNetworkCommissioningInteractionInfo.put( - "readInterfaceEnabledAttribute", - readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkingStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readLastNetworkingStatusAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningLastNetworkingStatusCommandParams); - readNetworkCommissioningInteractionInfo.put( - "readLastNetworkingStatusAttribute", - readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkIDCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readLastNetworkIDAttribute((ChipClusters.OctetStringAttributeCallback) callback); - }, + readNetworkCommissioningInterfaceEnabledCommandParams + ); + readNetworkCommissioningInteractionInfo.put("readInterfaceEnabledAttribute", readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkingStatusCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkingStatusAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningLastNetworkingStatusCommandParams + ); + readNetworkCommissioningInteractionInfo.put("readLastNetworkingStatusAttribute", readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkIDCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkIDAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readNetworkCommissioningLastNetworkIDCommandParams); - readNetworkCommissioningInteractionInfo.put( - "readLastNetworkIDAttribute", - readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); - Map readNetworkCommissioningLastConnectErrorValueCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readLastConnectErrorValueAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readNetworkCommissioningLastNetworkIDCommandParams + ); + readNetworkCommissioningInteractionInfo.put("readLastNetworkIDAttribute", readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); + Map readNetworkCommissioningLastConnectErrorValueCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readLastConnectErrorValueAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningLastConnectErrorValueCommandParams); - readNetworkCommissioningInteractionInfo.put( - "readLastConnectErrorValueAttribute", - readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); - Map readNetworkCommissioningFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readNetworkCommissioningLastConnectErrorValueCommandParams + ); + readNetworkCommissioningInteractionInfo.put("readLastConnectErrorValueAttribute", readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); + Map readNetworkCommissioningFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster).readFeatureMapAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningFeatureMapCommandParams); - readNetworkCommissioningInteractionInfo.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); - readNetworkCommissioningInteractionInfo.put( - "readClusterRevisionAttribute", - readNetworkCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("networkCommissioning", readNetworkCommissioningInteractionInfo); - Map readOtaSoftwareUpdateProviderInteractionInfo = - new LinkedHashMap<>(); - Map readOtaSoftwareUpdateProviderAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateProviderAttributeListCommandParams); - readOtaSoftwareUpdateProviderInteractionInfo.put( - "readAttributeListAttribute", - readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateProviderClusterRevisionCommandParams); - readOtaSoftwareUpdateProviderInteractionInfo.put( - "readClusterRevisionAttribute", - readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo); - Map readOtaSoftwareUpdateRequestorInteractionInfo = - 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); - readOtaSoftwareUpdateRequestorInteractionInfo.put( - "readDefaultOtaProvidersAttribute", - readOtaSoftwareUpdateRequestorDefaultOtaProvidersAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readUpdatePossibleAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readNetworkCommissioningFeatureMapCommandParams + ); + readNetworkCommissioningInteractionInfo.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 + ); + readNetworkCommissioningInteractionInfo.put("readClusterRevisionAttribute", readNetworkCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("networkCommissioning", readNetworkCommissioningInteractionInfo); + Map readOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); + Map readOtaSoftwareUpdateProviderAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateProviderAttributeListCommandParams + ); + readOtaSoftwareUpdateProviderInteractionInfo.put("readAttributeListAttribute", readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateProviderClusterRevisionCommandParams + ); + readOtaSoftwareUpdateProviderInteractionInfo.put("readClusterRevisionAttribute", readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo); + Map readOtaSoftwareUpdateRequestorInteractionInfo = 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 + ); + readOtaSoftwareUpdateRequestorInteractionInfo.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); - readOtaSoftwareUpdateRequestorInteractionInfo.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); - readOtaSoftwareUpdateRequestorInteractionInfo.put( - "readUpdateStateAttribute", - readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); - Map - readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readUpdateStateProgressAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster - .UpdateStateProgressAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams); - readOtaSoftwareUpdateRequestorInteractionInfo.put( - "readUpdateStateProgressAttribute", - readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OtaSoftwareUpdateRequestorCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateRequestorAttributeListCommandParams); - readOtaSoftwareUpdateRequestorInteractionInfo.put( - "readAttributeListAttribute", - readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorClusterRevisionCommandParams); - readOtaSoftwareUpdateRequestorInteractionInfo.put( - "readClusterRevisionAttribute", - readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo); - Map readOccupancySensingInteractionInfo = new LinkedHashMap<>(); - Map readOccupancySensingOccupancyCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readOccupancyAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingOccupancyCommandParams); - readOccupancySensingInteractionInfo.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); - readOccupancySensingInteractionInfo.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); - readOccupancySensingInteractionInfo.put( - "readOccupancySensorTypeBitmapAttribute", - readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); - Map readOccupancySensingAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOccupancySensingClusterAttributeListAttributeCallback(), - readOccupancySensingAttributeListCommandParams); - readOccupancySensingInteractionInfo.put( - "readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); - Map readOccupancySensingClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingClusterRevisionCommandParams); - readOccupancySensingInteractionInfo.put( - "readClusterRevisionAttribute", - readOccupancySensingClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("occupancySensing", readOccupancySensingInteractionInfo); - Map readOnOffInteractionInfo = new LinkedHashMap<>(); - Map readOnOffOnOffCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffOnOffAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readOnOffAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams + ); + readOtaSoftwareUpdateRequestorInteractionInfo.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 + ); + readOtaSoftwareUpdateRequestorInteractionInfo.put("readUpdateStateAttribute", readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdateStateProgressAttribute( + ( ChipClusters.OtaSoftwareUpdateRequestorCluster.UpdateStateProgressAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams + ); + readOtaSoftwareUpdateRequestorInteractionInfo.put("readUpdateStateProgressAttribute", readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OtaSoftwareUpdateRequestorCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateRequestorAttributeListCommandParams + ); + readOtaSoftwareUpdateRequestorInteractionInfo.put("readAttributeListAttribute", readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorClusterRevisionCommandParams + ); + readOtaSoftwareUpdateRequestorInteractionInfo.put("readClusterRevisionAttribute", readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo); + Map readOccupancySensingInteractionInfo = new LinkedHashMap<>(); + Map readOccupancySensingOccupancyCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readOccupancyAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingOccupancyCommandParams + ); + readOccupancySensingInteractionInfo.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 + ); + readOccupancySensingInteractionInfo.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 + ); + readOccupancySensingInteractionInfo.put("readOccupancySensorTypeBitmapAttribute", readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); + Map readOccupancySensingAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterAttributeListAttributeCallback(), + readOccupancySensingAttributeListCommandParams + ); + readOccupancySensingInteractionInfo.put("readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); + Map readOccupancySensingClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingClusterRevisionCommandParams + ); + readOccupancySensingInteractionInfo.put("readClusterRevisionAttribute", readOccupancySensingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("occupancySensing", readOccupancySensingInteractionInfo); + Map readOnOffInteractionInfo = new LinkedHashMap<>(); + Map readOnOffOnOffCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffOnOffAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readOnOffAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOnOffOnOffCommandParams); - readOnOffInteractionInfo.put("readOnOffAttribute", readOnOffOnOffAttributeInteractionInfo); - Map readOnOffGlobalSceneControlCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffGlobalSceneControlAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readGlobalSceneControlAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readOnOffOnOffCommandParams + ); + readOnOffInteractionInfo.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); - readOnOffInteractionInfo.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); - readOnOffInteractionInfo.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); - readOnOffInteractionInfo.put( - "readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); - Map readOnOffStartUpOnOffCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readStartUpOnOffAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffStartUpOnOffCommandParams); - readOnOffInteractionInfo.put( - "readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); - Map readOnOffAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OnOffCluster.AttributeListAttributeCallback) callback); - }, + readOnOffGlobalSceneControlCommandParams + ); + readOnOffInteractionInfo.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 + ); + readOnOffInteractionInfo.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 + ); + readOnOffInteractionInfo.put("readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); + Map readOnOffStartUpOnOffCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readStartUpOnOffAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffStartUpOnOffCommandParams + ); + readOnOffInteractionInfo.put("readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); + Map readOnOffAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OnOffCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOnOffClusterAttributeListAttributeCallback(), - readOnOffAttributeListCommandParams); - readOnOffInteractionInfo.put( - "readAttributeListAttribute", readOnOffAttributeListAttributeInteractionInfo); - Map readOnOffFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readOnOffAttributeListCommandParams + ); + readOnOffInteractionInfo.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); - readOnOffInteractionInfo.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); - readOnOffInteractionInfo.put( - "readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("onOff", readOnOffInteractionInfo); - Map readOnOffSwitchConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map readOnOffSwitchConfigurationSwitchTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readSwitchTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationSwitchTypeCommandParams); - readOnOffSwitchConfigurationInteractionInfo.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); - readOnOffSwitchConfigurationInteractionInfo.put( - "readSwitchActionsAttribute", - readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); - Map readOnOffSwitchConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), - readOnOffSwitchConfigurationAttributeListCommandParams); - readOnOffSwitchConfigurationInteractionInfo.put( - "readAttributeListAttribute", - readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationClusterRevisionCommandParams); - readOnOffSwitchConfigurationInteractionInfo.put( - "readClusterRevisionAttribute", - readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo); - Map readOperationalCredentialsInteractionInfo = 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); - readOperationalCredentialsInteractionInfo.put( - "readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); - Map readOperationalCredentialsFabricsListCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsFabricsListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readFabricsListAttribute( - (ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOperationalCredentialsClusterFabricsListAttributeCallback(), - readOperationalCredentialsFabricsListCommandParams); - readOperationalCredentialsInteractionInfo.put( - "readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeInteractionInfo); - Map readOperationalCredentialsSupportedFabricsCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readSupportedFabricsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsSupportedFabricsCommandParams); - readOperationalCredentialsInteractionInfo.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); - readOperationalCredentialsInteractionInfo.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); - readOperationalCredentialsInteractionInfo.put( - "readTrustedRootCertificatesAttribute", - readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); - Map readOperationalCredentialsCurrentFabricIndexCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readCurrentFabricIndexAttribute( - (ChipClusters.OperationalCredentialsCluster - .CurrentFabricIndexAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsCurrentFabricIndexCommandParams); - readOperationalCredentialsInteractionInfo.put( - "readCurrentFabricIndexAttribute", - readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); - Map readOperationalCredentialsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), - readOperationalCredentialsAttributeListCommandParams); - readOperationalCredentialsInteractionInfo.put( - "readAttributeListAttribute", - readOperationalCredentialsAttributeListAttributeInteractionInfo); - Map readOperationalCredentialsClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsClusterRevisionCommandParams); - readOperationalCredentialsInteractionInfo.put( - "readClusterRevisionAttribute", - readOperationalCredentialsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("operationalCredentials", readOperationalCredentialsInteractionInfo); - Map readPowerSourceInteractionInfo = new LinkedHashMap<>(); - Map readPowerSourceStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceStatusCommandParams); - readPowerSourceInteractionInfo.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); - readPowerSourceInteractionInfo.put( - "readOrderAttribute", readPowerSourceOrderAttributeInteractionInfo); - Map readPowerSourceDescriptionCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceDescriptionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readOnOffFeatureMapCommandParams + ); + readOnOffInteractionInfo.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 + ); + readOnOffInteractionInfo.put("readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOff", readOnOffInteractionInfo); + Map readOnOffSwitchConfigurationInteractionInfo = new LinkedHashMap<>(); + Map readOnOffSwitchConfigurationSwitchTypeCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readSwitchTypeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationSwitchTypeCommandParams + ); + readOnOffSwitchConfigurationInteractionInfo.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 + ); + readOnOffSwitchConfigurationInteractionInfo.put("readSwitchActionsAttribute", readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); + Map readOnOffSwitchConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), + readOnOffSwitchConfigurationAttributeListCommandParams + ); + readOnOffSwitchConfigurationInteractionInfo.put("readAttributeListAttribute", readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationClusterRevisionCommandParams + ); + readOnOffSwitchConfigurationInteractionInfo.put("readClusterRevisionAttribute", readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo); + Map readOperationalCredentialsInteractionInfo = 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 + ); + readOperationalCredentialsInteractionInfo.put("readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); + Map readOperationalCredentialsFabricsListCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsFabricsListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readFabricsListAttribute( + ( ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterFabricsListAttributeCallback(), + readOperationalCredentialsFabricsListCommandParams + ); + readOperationalCredentialsInteractionInfo.put("readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeInteractionInfo); + Map readOperationalCredentialsSupportedFabricsCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readSupportedFabricsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsSupportedFabricsCommandParams + ); + readOperationalCredentialsInteractionInfo.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 + ); + readOperationalCredentialsInteractionInfo.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 + ); + readOperationalCredentialsInteractionInfo.put("readTrustedRootCertificatesAttribute", readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); + Map readOperationalCredentialsCurrentFabricIndexCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readCurrentFabricIndexAttribute( + ( ChipClusters.OperationalCredentialsCluster.CurrentFabricIndexAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsCurrentFabricIndexCommandParams + ); + readOperationalCredentialsInteractionInfo.put("readCurrentFabricIndexAttribute", readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); + Map readOperationalCredentialsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), + readOperationalCredentialsAttributeListCommandParams + ); + readOperationalCredentialsInteractionInfo.put("readAttributeListAttribute", readOperationalCredentialsAttributeListAttributeInteractionInfo); + Map readOperationalCredentialsClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsClusterRevisionCommandParams + ); + readOperationalCredentialsInteractionInfo.put("readClusterRevisionAttribute", readOperationalCredentialsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("operationalCredentials", readOperationalCredentialsInteractionInfo); + Map readPowerSourceInteractionInfo = new LinkedHashMap<>(); + Map readPowerSourceStatusCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readStatusAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceStatusCommandParams + ); + readPowerSourceInteractionInfo.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 + ); + readPowerSourceInteractionInfo.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); - readPowerSourceInteractionInfo.put( - "readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); - Map readPowerSourceBatteryVoltageCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryVoltageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatteryVoltageAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readPowerSourceDescriptionCommandParams + ); + readPowerSourceInteractionInfo.put("readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); + Map readPowerSourceBatteryVoltageCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryVoltageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatteryVoltageAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatteryVoltageCommandParams); - readPowerSourceInteractionInfo.put( - "readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeInteractionInfo); - Map readPowerSourceBatteryPercentRemainingCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryPercentRemainingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatteryPercentRemainingAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryPercentRemainingCommandParams); - readPowerSourceInteractionInfo.put( - "readBatteryPercentRemainingAttribute", - readPowerSourceBatteryPercentRemainingAttributeInteractionInfo); - Map readPowerSourceBatteryTimeRemainingCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryTimeRemainingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatteryTimeRemainingAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readPowerSourceBatteryVoltageCommandParams + ); + readPowerSourceInteractionInfo.put("readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeInteractionInfo); + Map readPowerSourceBatteryPercentRemainingCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryPercentRemainingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatteryPercentRemainingAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryPercentRemainingCommandParams + ); + readPowerSourceInteractionInfo.put("readBatteryPercentRemainingAttribute", readPowerSourceBatteryPercentRemainingAttributeInteractionInfo); + Map readPowerSourceBatteryTimeRemainingCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryTimeRemainingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatteryTimeRemainingAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatteryTimeRemainingCommandParams); - readPowerSourceInteractionInfo.put( - "readBatteryTimeRemainingAttribute", - readPowerSourceBatteryTimeRemainingAttributeInteractionInfo); - Map readPowerSourceBatteryChargeLevelCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryChargeLevelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatteryChargeLevelAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryChargeLevelCommandParams); - readPowerSourceInteractionInfo.put( - "readBatteryChargeLevelAttribute", - readPowerSourceBatteryChargeLevelAttributeInteractionInfo); - Map readPowerSourceActiveBatteryFaultsCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceActiveBatteryFaultsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readActiveBatteryFaultsAttribute( - (ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback(), - readPowerSourceActiveBatteryFaultsCommandParams); - readPowerSourceInteractionInfo.put( - "readActiveBatteryFaultsAttribute", - readPowerSourceActiveBatteryFaultsAttributeInteractionInfo); - Map readPowerSourceBatteryChargeStateCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryChargeStateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readBatteryChargeStateAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryChargeStateCommandParams); - readPowerSourceInteractionInfo.put( - "readBatteryChargeStateAttribute", - readPowerSourceBatteryChargeStateAttributeInteractionInfo); - Map readPowerSourceAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PowerSourceCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), - readPowerSourceAttributeListCommandParams); - readPowerSourceInteractionInfo.put( - "readAttributeListAttribute", readPowerSourceAttributeListAttributeInteractionInfo); - Map readPowerSourceFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readPowerSourceBatteryTimeRemainingCommandParams + ); + readPowerSourceInteractionInfo.put("readBatteryTimeRemainingAttribute", readPowerSourceBatteryTimeRemainingAttributeInteractionInfo); + Map readPowerSourceBatteryChargeLevelCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryChargeLevelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatteryChargeLevelAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryChargeLevelCommandParams + ); + readPowerSourceInteractionInfo.put("readBatteryChargeLevelAttribute", readPowerSourceBatteryChargeLevelAttributeInteractionInfo); + Map readPowerSourceActiveBatteryFaultsCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceActiveBatteryFaultsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readActiveBatteryFaultsAttribute( + ( ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback(), + readPowerSourceActiveBatteryFaultsCommandParams + ); + readPowerSourceInteractionInfo.put("readActiveBatteryFaultsAttribute", readPowerSourceActiveBatteryFaultsAttributeInteractionInfo); + Map readPowerSourceBatteryChargeStateCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryChargeStateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readBatteryChargeStateAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryChargeStateCommandParams + ); + readPowerSourceInteractionInfo.put("readBatteryChargeStateAttribute", readPowerSourceBatteryChargeStateAttributeInteractionInfo); + Map readPowerSourceAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster).readAttributeListAttribute( + ( ChipClusters.PowerSourceCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), + readPowerSourceAttributeListCommandParams + ); + readPowerSourceInteractionInfo.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); - readPowerSourceInteractionInfo.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); - readPowerSourceInteractionInfo.put( - "readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("powerSource", readPowerSourceInteractionInfo); - Map readPowerSourceConfigurationInteractionInfo = - 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); - readPowerSourceConfigurationInteractionInfo.put( - "readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); - Map readPowerSourceConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), - readPowerSourceConfigurationAttributeListCommandParams); - readPowerSourceConfigurationInteractionInfo.put( - "readAttributeListAttribute", - readPowerSourceConfigurationAttributeListAttributeInteractionInfo); - Map readPowerSourceConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceConfigurationClusterRevisionCommandParams); - readPowerSourceConfigurationInteractionInfo.put( - "readClusterRevisionAttribute", - readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo); - Map readPressureMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readPressureMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMeasuredValueCommandParams); - readPressureMeasurementInteractionInfo.put( - "readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMinMeasuredValueCommandParams); - readPressureMeasurementInteractionInfo.put( - "readMinMeasuredValueAttribute", - readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMaxMeasuredValueCommandParams); - readPressureMeasurementInteractionInfo.put( - "readMaxMeasuredValueAttribute", - readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), - readPressureMeasurementAttributeListCommandParams); - readPressureMeasurementInteractionInfo.put( - "readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); - Map readPressureMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementClusterRevisionCommandParams); - readPressureMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", - readPressureMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("pressureMeasurement", readPressureMeasurementInteractionInfo); - Map readPumpConfigurationAndControlInteractionInfo = - new LinkedHashMap<>(); - Map readPumpConfigurationAndControlMaxPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxPressureCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxPressureAttribute", - readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxSpeedCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxFlowCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxFlowCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstPressureCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMinConstPressureAttribute", - readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstPressureCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxConstPressureAttribute", - readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinCompPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinCompPressureCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMinCompPressureAttribute", - readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxCompPressureCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxCompPressureCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxCompPressureAttribute", - readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstSpeedCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMinConstSpeedAttribute", - readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstSpeedCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxConstSpeedAttribute", - readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstFlowCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstFlowCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMinConstFlowAttribute", - readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstFlowCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstFlowCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMaxConstFlowAttribute", - readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstTempCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMinConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstTempCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readMinConstTempAttribute", - readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstTempCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readMaxConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstTempCommandParams); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.put( - "readEffectiveControlModeAttribute", - readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlCapacityCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readCapacityAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlCapacityCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); - Map readPumpConfigurationAndControlSpeedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlSpeedCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); - Map - readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readLifetimeRunningHoursAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .LifetimeRunningHoursAttributeCallback) - callback); - }, + readPowerSourceFeatureMapCommandParams + ); + readPowerSourceInteractionInfo.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 + ); + readPowerSourceInteractionInfo.put("readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("powerSource", readPowerSourceInteractionInfo); + Map readPowerSourceConfigurationInteractionInfo = 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 + ); + readPowerSourceConfigurationInteractionInfo.put("readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); + Map readPowerSourceConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster).readAttributeListAttribute( + ( ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), + readPowerSourceConfigurationAttributeListCommandParams + ); + readPowerSourceConfigurationInteractionInfo.put("readAttributeListAttribute", readPowerSourceConfigurationAttributeListAttributeInteractionInfo); + Map readPowerSourceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceConfigurationClusterRevisionCommandParams + ); + readPowerSourceConfigurationInteractionInfo.put("readClusterRevisionAttribute", readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo); + Map readPressureMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readPressureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMeasuredValueCommandParams + ); + readPressureMeasurementInteractionInfo.put("readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readMinMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMinMeasuredValueCommandParams + ); + readPressureMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMaxMeasuredValueCommandParams + ); + readPressureMeasurementInteractionInfo.put("readMaxMeasuredValueAttribute", readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), + readPressureMeasurementAttributeListCommandParams + ); + readPressureMeasurementInteractionInfo.put("readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); + Map readPressureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementClusterRevisionCommandParams + ); + readPressureMeasurementInteractionInfo.put("readClusterRevisionAttribute", readPressureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("pressureMeasurement", readPressureMeasurementInteractionInfo); + Map readPumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); + Map readPumpConfigurationAndControlMaxPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxPressureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxPressureCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxPressureAttribute", readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxSpeedAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxSpeedCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxFlowCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxFlowAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxFlowCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstPressureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstPressureCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMinConstPressureAttribute", readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstPressureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstPressureCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxConstPressureAttribute", readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinCompPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinCompPressureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinCompPressureCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMinCompPressureAttribute", readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxCompPressureCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxCompPressureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxCompPressureCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxCompPressureAttribute", readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstSpeedAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstSpeedCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMinConstSpeedAttribute", readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstSpeedAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstSpeedCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxConstSpeedAttribute", readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstFlowCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstFlowAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstFlowCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMinConstFlowAttribute", readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstFlowCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstFlowAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstFlowCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMaxConstFlowAttribute", readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstTempCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstTempAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstTempCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readMinConstTempAttribute", readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstTempCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstTempAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstTempCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.put("readEffectiveControlModeAttribute", readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlCapacityCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readCapacityAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlCapacityCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); + Map readPumpConfigurationAndControlSpeedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readSpeedAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlSpeedCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeRunningHoursAttribute( + ( ChipClusters.PumpConfigurationAndControlCluster.LifetimeRunningHoursAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlLifetimeRunningHoursCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readLifetimeRunningHoursAttribute", - readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); - Map readPumpConfigurationAndControlPowerCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readPowerAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readPumpConfigurationAndControlLifetimeRunningHoursCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readLifetimeRunningHoursAttribute", readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); + Map readPumpConfigurationAndControlPowerCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readPowerAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlPowerCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); - Map - readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readLifetimeEnergyConsumedAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .LifetimeEnergyConsumedAttributeCallback) - callback); - }, + readPumpConfigurationAndControlPowerCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); + Map readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeEnergyConsumedAttribute( + ( ChipClusters.PumpConfigurationAndControlCluster.LifetimeEnergyConsumedAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.put( - "readControlModeAttribute", - readPumpConfigurationAndControlControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlAlarmMaskCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readAlarmMaskAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlAlarmMaskCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo); - Map readPumpConfigurationAndControlAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.PumpConfigurationAndControlCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), - readPumpConfigurationAndControlAttributeListCommandParams); - readPumpConfigurationAndControlInteractionInfo.put( - "readAttributeListAttribute", - readPumpConfigurationAndControlAttributeListAttributeInteractionInfo); - Map readPumpConfigurationAndControlFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.put("readControlModeAttribute", readPumpConfigurationAndControlControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlAlarmMaskCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAlarmMaskAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlAlarmMaskCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.put("readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo); + Map readPumpConfigurationAndControlAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAttributeListAttribute( + ( ChipClusters.PumpConfigurationAndControlCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), + readPumpConfigurationAndControlAttributeListCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.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); - readPumpConfigurationAndControlInteractionInfo.put( - "readClusterRevisionAttribute", - readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo); - Map readRelativeHumidityMeasurementInteractionInfo = - new LinkedHashMap<>(); - Map readRelativeHumidityMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMeasuredValueCommandParams); - readRelativeHumidityMeasurementInteractionInfo.put( - "readMeasuredValueAttribute", - readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMinMeasuredValueCommandParams); - readRelativeHumidityMeasurementInteractionInfo.put( - "readMinMeasuredValueAttribute", - readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMaxMeasuredValueCommandParams); - readRelativeHumidityMeasurementInteractionInfo.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); - readRelativeHumidityMeasurementInteractionInfo.put( - "readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); - Map readRelativeHumidityMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.RelativeHumidityMeasurementCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), - readRelativeHumidityMeasurementAttributeListCommandParams); - readRelativeHumidityMeasurementInteractionInfo.put( - "readAttributeListAttribute", - readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementClusterRevisionCommandParams); - readRelativeHumidityMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", - readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo); - Map readScenesInteractionInfo = new LinkedHashMap<>(); - Map readScenesSceneCountCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesSceneCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readSceneCountAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesSceneCountCommandParams); - readScenesInteractionInfo.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); - readScenesInteractionInfo.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); - readScenesInteractionInfo.put( - "readCurrentGroupAttribute", readScenesCurrentGroupAttributeInteractionInfo); - Map readScenesSceneValidCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesSceneValidAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readSceneValidAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readPumpConfigurationAndControlFeatureMapCommandParams + ); + readPumpConfigurationAndControlInteractionInfo.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 + ); + readPumpConfigurationAndControlInteractionInfo.put("readClusterRevisionAttribute", readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo); + Map readRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readRelativeHumidityMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMeasuredValueCommandParams + ); + readRelativeHumidityMeasurementInteractionInfo.put("readMeasuredValueAttribute", readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMinMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMinMeasuredValueCommandParams + ); + readRelativeHumidityMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMaxMeasuredValueCommandParams + ); + readRelativeHumidityMeasurementInteractionInfo.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 + ); + readRelativeHumidityMeasurementInteractionInfo.put("readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); + Map readRelativeHumidityMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.RelativeHumidityMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), + readRelativeHumidityMeasurementAttributeListCommandParams + ); + readRelativeHumidityMeasurementInteractionInfo.put("readAttributeListAttribute", readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementClusterRevisionCommandParams + ); + readRelativeHumidityMeasurementInteractionInfo.put("readClusterRevisionAttribute", readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo); + Map readScenesInteractionInfo = new LinkedHashMap<>(); + Map readScenesSceneCountCommandParams = new LinkedHashMap(); + InteractionInfo readScenesSceneCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readSceneCountAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesSceneCountCommandParams + ); + readScenesInteractionInfo.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 + ); + readScenesInteractionInfo.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 + ); + readScenesInteractionInfo.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); - readScenesInteractionInfo.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); - readScenesInteractionInfo.put( - "readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); - Map readScenesAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ScenesCluster.AttributeListAttributeCallback) callback); - }, + readScenesSceneValidCommandParams + ); + readScenesInteractionInfo.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 + ); + readScenesInteractionInfo.put("readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); + Map readScenesAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readScenesAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ScenesCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedScenesClusterAttributeListAttributeCallback(), - readScenesAttributeListCommandParams); - readScenesInteractionInfo.put( - "readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); - Map readScenesClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesClusterRevisionCommandParams); - readScenesInteractionInfo.put( - "readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("scenes", readScenesInteractionInfo); - Map readSoftwareDiagnosticsInteractionInfo = 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); - readSoftwareDiagnosticsInteractionInfo.put( - "readThreadMetricsAttribute", readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapFreeCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readCurrentHeapFreeAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readScenesAttributeListCommandParams + ); + readScenesInteractionInfo.put("readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); + Map readScenesClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesClusterRevisionCommandParams + ); + readScenesInteractionInfo.put("readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("scenes", readScenesInteractionInfo); + Map readSoftwareDiagnosticsInteractionInfo = 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 + ); + readSoftwareDiagnosticsInteractionInfo.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); - readSoftwareDiagnosticsInteractionInfo.put( - "readCurrentHeapFreeAttribute", - readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapUsedCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readCurrentHeapUsedAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readSoftwareDiagnosticsCurrentHeapFreeCommandParams + ); + readSoftwareDiagnosticsInteractionInfo.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); - readSoftwareDiagnosticsInteractionInfo.put( - "readCurrentHeapUsedAttribute", - readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readCurrentHeapHighWatermarkAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readSoftwareDiagnosticsCurrentHeapUsedCommandParams + ); + readSoftwareDiagnosticsInteractionInfo.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); - readSoftwareDiagnosticsInteractionInfo.put( - "readCurrentHeapHighWatermarkAttribute", - readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); - Map readSoftwareDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), - readSoftwareDiagnosticsAttributeListCommandParams); - readSoftwareDiagnosticsInteractionInfo.put( - "readAttributeListAttribute", readSoftwareDiagnosticsAttributeListAttributeInteractionInfo); - Map readSoftwareDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams + ); + readSoftwareDiagnosticsInteractionInfo.put("readCurrentHeapHighWatermarkAttribute", readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); + Map readSoftwareDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), + readSoftwareDiagnosticsAttributeListCommandParams + ); + readSoftwareDiagnosticsInteractionInfo.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); - readSoftwareDiagnosticsInteractionInfo.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); - readSoftwareDiagnosticsInteractionInfo.put( - "readClusterRevisionAttribute", - readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo); - Map readSwitchInteractionInfo = new LinkedHashMap<>(); - Map readSwitchNumberOfPositionsCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readNumberOfPositionsAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchNumberOfPositionsCommandParams); - readSwitchInteractionInfo.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); - readSwitchInteractionInfo.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); - readSwitchInteractionInfo.put( - "readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); - Map readSwitchAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.SwitchCluster.AttributeListAttributeCallback) callback); - }, + readSoftwareDiagnosticsFeatureMapCommandParams + ); + readSoftwareDiagnosticsInteractionInfo.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 + ); + readSoftwareDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo); + Map readSwitchInteractionInfo = new LinkedHashMap<>(); + Map readSwitchNumberOfPositionsCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readNumberOfPositionsAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchNumberOfPositionsCommandParams + ); + readSwitchInteractionInfo.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 + ); + readSwitchInteractionInfo.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 + ); + readSwitchInteractionInfo.put("readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); + Map readSwitchAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readSwitchAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster).readAttributeListAttribute( + ( ChipClusters.SwitchCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedSwitchClusterAttributeListAttributeCallback(), - readSwitchAttributeListCommandParams); - readSwitchInteractionInfo.put( - "readAttributeListAttribute", readSwitchAttributeListAttributeInteractionInfo); - Map readSwitchFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readSwitchFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readSwitchAttributeListCommandParams + ); + readSwitchInteractionInfo.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); - readSwitchInteractionInfo.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); - readSwitchInteractionInfo.put( - "readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("switch", readSwitchInteractionInfo); - Map readTargetNavigatorInteractionInfo = new LinkedHashMap<>(); - Map readTargetNavigatorTargetNavigatorListCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorTargetNavigatorListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readTargetNavigatorListAttribute( - (ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback(), - readTargetNavigatorTargetNavigatorListCommandParams); - readTargetNavigatorInteractionInfo.put( - "readTargetNavigatorListAttribute", - readTargetNavigatorTargetNavigatorListAttributeInteractionInfo); - Map readTargetNavigatorCurrentNavigatorTargetCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readCurrentNavigatorTargetAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorCurrentNavigatorTargetCommandParams); - readTargetNavigatorInteractionInfo.put( - "readCurrentNavigatorTargetAttribute", - readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo); - Map readTargetNavigatorAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), - readTargetNavigatorAttributeListCommandParams); - readTargetNavigatorInteractionInfo.put( - "readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); - Map readTargetNavigatorClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorClusterRevisionCommandParams); - readTargetNavigatorInteractionInfo.put( - "readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("targetNavigator", readTargetNavigatorInteractionInfo); - Map readTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readTemperatureMeasurementMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMeasuredValueCommandParams); - readTemperatureMeasurementInteractionInfo.put( - "readMeasuredValueAttribute", - readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMinMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMinMeasuredValueCommandParams); - readTemperatureMeasurementInteractionInfo.put( - "readMinMeasuredValueAttribute", - readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMaxMeasuredValueCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMaxMeasuredValueCommandParams); - readTemperatureMeasurementInteractionInfo.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); - readTemperatureMeasurementInteractionInfo.put( - "readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); - Map readTemperatureMeasurementAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), - readTemperatureMeasurementAttributeListCommandParams); - readTemperatureMeasurementInteractionInfo.put( - "readAttributeListAttribute", - readTemperatureMeasurementAttributeListAttributeInteractionInfo); - Map readTemperatureMeasurementClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementClusterRevisionCommandParams); - readTemperatureMeasurementInteractionInfo.put( - "readClusterRevisionAttribute", - readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo); - Map readTestClusterInteractionInfo = new LinkedHashMap<>(); - Map readTestClusterBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readSwitchFeatureMapCommandParams + ); + readSwitchInteractionInfo.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 + ); + readSwitchInteractionInfo.put("readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("switch", readSwitchInteractionInfo); + Map readTargetNavigatorInteractionInfo = new LinkedHashMap<>(); + Map readTargetNavigatorTargetNavigatorListCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorTargetNavigatorListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readTargetNavigatorListAttribute( + ( ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback(), + readTargetNavigatorTargetNavigatorListCommandParams + ); + readTargetNavigatorInteractionInfo.put("readTargetNavigatorListAttribute", readTargetNavigatorTargetNavigatorListAttributeInteractionInfo); + Map readTargetNavigatorCurrentNavigatorTargetCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readCurrentNavigatorTargetAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorCurrentNavigatorTargetCommandParams + ); + readTargetNavigatorInteractionInfo.put("readCurrentNavigatorTargetAttribute", readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo); + Map readTargetNavigatorAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readAttributeListAttribute( + ( ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), + readTargetNavigatorAttributeListCommandParams + ); + readTargetNavigatorInteractionInfo.put("readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); + Map readTargetNavigatorClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorClusterRevisionCommandParams + ); + readTargetNavigatorInteractionInfo.put("readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("targetNavigator", readTargetNavigatorInteractionInfo); + Map readTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readTemperatureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMeasuredValueCommandParams + ); + readTemperatureMeasurementInteractionInfo.put("readMeasuredValueAttribute", readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readMinMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMinMeasuredValueCommandParams + ); + readTemperatureMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMaxMeasuredValueCommandParams + ); + readTemperatureMeasurementInteractionInfo.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 + ); + readTemperatureMeasurementInteractionInfo.put("readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); + Map readTemperatureMeasurementAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readAttributeListAttribute( + ( ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), + readTemperatureMeasurementAttributeListCommandParams + ); + readTemperatureMeasurementInteractionInfo.put("readAttributeListAttribute", readTemperatureMeasurementAttributeListAttributeInteractionInfo); + Map readTemperatureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementClusterRevisionCommandParams + ); + readTemperatureMeasurementInteractionInfo.put("readClusterRevisionAttribute", readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo); + Map readTestClusterInteractionInfo = new LinkedHashMap<>(); + Map readTestClusterBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readBooleanAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterBooleanCommandParams); - readTestClusterInteractionInfo.put( - "readBooleanAttribute", readTestClusterBooleanAttributeInteractionInfo); - Map readTestClusterBitmap8CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readBitmap8Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterBitmap8CommandParams); - readTestClusterInteractionInfo.put( - "readBitmap8Attribute", readTestClusterBitmap8AttributeInteractionInfo); - Map readTestClusterBitmap16CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readBitmap16Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterBitmap16CommandParams); - readTestClusterInteractionInfo.put( - "readBitmap16Attribute", readTestClusterBitmap16AttributeInteractionInfo); - Map readTestClusterBitmap32CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readBitmap32Attribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterBooleanCommandParams + ); + readTestClusterInteractionInfo.put("readBooleanAttribute", readTestClusterBooleanAttributeInteractionInfo); + Map readTestClusterBitmap8CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readBitmap8Attribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterBitmap8CommandParams + ); + readTestClusterInteractionInfo.put("readBitmap8Attribute", readTestClusterBitmap8AttributeInteractionInfo); + Map readTestClusterBitmap16CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readBitmap16Attribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterBitmap16CommandParams + ); + readTestClusterInteractionInfo.put("readBitmap16Attribute", readTestClusterBitmap16AttributeInteractionInfo); + Map readTestClusterBitmap32CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readBitmap32Attribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterBitmap32CommandParams); - readTestClusterInteractionInfo.put( - "readBitmap32Attribute", readTestClusterBitmap32AttributeInteractionInfo); - Map readTestClusterBitmap64CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readBitmap64Attribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterBitmap32CommandParams + ); + readTestClusterInteractionInfo.put("readBitmap32Attribute", readTestClusterBitmap32AttributeInteractionInfo); + Map readTestClusterBitmap64CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readBitmap64Attribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterBitmap64CommandParams); - readTestClusterInteractionInfo.put( - "readBitmap64Attribute", readTestClusterBitmap64AttributeInteractionInfo); - Map readTestClusterInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt8uAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt8uCommandParams); - readTestClusterInteractionInfo.put( - "readInt8uAttribute", readTestClusterInt8uAttributeInteractionInfo); - Map readTestClusterInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt16uAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt16uCommandParams); - readTestClusterInteractionInfo.put( - "readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); - Map readTestClusterInt24uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt24uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterBitmap64CommandParams + ); + readTestClusterInteractionInfo.put("readBitmap64Attribute", readTestClusterBitmap64AttributeInteractionInfo); + Map readTestClusterInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt8uAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt8uCommandParams + ); + readTestClusterInteractionInfo.put("readInt8uAttribute", readTestClusterInt8uAttributeInteractionInfo); + Map readTestClusterInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt16uAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt16uCommandParams + ); + readTestClusterInteractionInfo.put("readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); + Map readTestClusterInt24uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt24uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt24uCommandParams); - readTestClusterInteractionInfo.put( - "readInt24uAttribute", readTestClusterInt24uAttributeInteractionInfo); - Map readTestClusterInt32uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt32uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt24uCommandParams + ); + readTestClusterInteractionInfo.put("readInt24uAttribute", readTestClusterInt24uAttributeInteractionInfo); + Map readTestClusterInt32uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt32uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt32uCommandParams); - readTestClusterInteractionInfo.put( - "readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); - Map readTestClusterInt40uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt40uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt32uCommandParams + ); + readTestClusterInteractionInfo.put("readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); + Map readTestClusterInt40uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt40uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt40uCommandParams); - readTestClusterInteractionInfo.put( - "readInt40uAttribute", readTestClusterInt40uAttributeInteractionInfo); - Map readTestClusterInt48uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt48uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt40uCommandParams + ); + readTestClusterInteractionInfo.put("readInt40uAttribute", readTestClusterInt40uAttributeInteractionInfo); + Map readTestClusterInt48uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt48uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt48uCommandParams); - readTestClusterInteractionInfo.put( - "readInt48uAttribute", readTestClusterInt48uAttributeInteractionInfo); - Map readTestClusterInt56uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt56uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt48uCommandParams + ); + readTestClusterInteractionInfo.put("readInt48uAttribute", readTestClusterInt48uAttributeInteractionInfo); + Map readTestClusterInt56uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt56uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt56uCommandParams); - readTestClusterInteractionInfo.put( - "readInt56uAttribute", readTestClusterInt56uAttributeInteractionInfo); - Map readTestClusterInt64uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt64uAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt56uCommandParams + ); + readTestClusterInteractionInfo.put("readInt56uAttribute", readTestClusterInt56uAttributeInteractionInfo); + Map readTestClusterInt64uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt64uAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt64uCommandParams); - readTestClusterInteractionInfo.put( - "readInt64uAttribute", readTestClusterInt64uAttributeInteractionInfo); - Map readTestClusterInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt8sAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt8sCommandParams); - readTestClusterInteractionInfo.put( - "readInt8sAttribute", readTestClusterInt8sAttributeInteractionInfo); - Map readTestClusterInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt16sAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt16sCommandParams); - readTestClusterInteractionInfo.put( - "readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); - Map readTestClusterInt24sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt24sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt64uCommandParams + ); + readTestClusterInteractionInfo.put("readInt64uAttribute", readTestClusterInt64uAttributeInteractionInfo); + Map readTestClusterInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt8sAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt8sCommandParams + ); + readTestClusterInteractionInfo.put("readInt8sAttribute", readTestClusterInt8sAttributeInteractionInfo); + Map readTestClusterInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt16sAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt16sCommandParams + ); + readTestClusterInteractionInfo.put("readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); + Map readTestClusterInt24sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt24sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt24sCommandParams); - readTestClusterInteractionInfo.put( - "readInt24sAttribute", readTestClusterInt24sAttributeInteractionInfo); - Map readTestClusterInt32sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt32sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt24sCommandParams + ); + readTestClusterInteractionInfo.put("readInt24sAttribute", readTestClusterInt24sAttributeInteractionInfo); + Map readTestClusterInt32sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt32sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt32sCommandParams); - readTestClusterInteractionInfo.put( - "readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); - Map readTestClusterInt40sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt40sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt32sCommandParams + ); + readTestClusterInteractionInfo.put("readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); + Map readTestClusterInt40sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt40sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt40sCommandParams); - readTestClusterInteractionInfo.put( - "readInt40sAttribute", readTestClusterInt40sAttributeInteractionInfo); - Map readTestClusterInt48sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt48sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt40sCommandParams + ); + readTestClusterInteractionInfo.put("readInt40sAttribute", readTestClusterInt40sAttributeInteractionInfo); + Map readTestClusterInt48sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt48sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt48sCommandParams); - readTestClusterInteractionInfo.put( - "readInt48sAttribute", readTestClusterInt48sAttributeInteractionInfo); - Map readTestClusterInt56sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt56sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt48sCommandParams + ); + readTestClusterInteractionInfo.put("readInt48sAttribute", readTestClusterInt48sAttributeInteractionInfo); + Map readTestClusterInt56sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt56sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt56sCommandParams); - readTestClusterInteractionInfo.put( - "readInt56sAttribute", readTestClusterInt56sAttributeInteractionInfo); - Map readTestClusterInt64sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readInt64sAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterInt56sCommandParams + ); + readTestClusterInteractionInfo.put("readInt56sAttribute", readTestClusterInt56sAttributeInteractionInfo); + Map readTestClusterInt64sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readInt64sAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt64sCommandParams); - readTestClusterInteractionInfo.put( - "readInt64sAttribute", readTestClusterInt64sAttributeInteractionInfo); - Map readTestClusterEnum8CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readEnum8Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnum8CommandParams); - readTestClusterInteractionInfo.put( - "readEnum8Attribute", readTestClusterEnum8AttributeInteractionInfo); - Map readTestClusterEnum16CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readEnum16Attribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnum16CommandParams); - readTestClusterInteractionInfo.put( - "readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); - Map readTestClusterFloatSingleCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readFloatSingleAttribute((ChipClusters.FloatAttributeCallback) callback); - }, + readTestClusterInt64sCommandParams + ); + readTestClusterInteractionInfo.put("readInt64sAttribute", readTestClusterInt64sAttributeInteractionInfo); + Map readTestClusterEnum8CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readEnum8Attribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnum8CommandParams + ); + readTestClusterInteractionInfo.put("readEnum8Attribute", readTestClusterEnum8AttributeInteractionInfo); + Map readTestClusterEnum16CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readEnum16Attribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnum16CommandParams + ); + readTestClusterInteractionInfo.put("readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); + Map readTestClusterFloatSingleCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readFloatSingleAttribute( + ( + ChipClusters.FloatAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readTestClusterFloatSingleCommandParams); - readTestClusterInteractionInfo.put( - "readFloatSingleAttribute", readTestClusterFloatSingleAttributeInteractionInfo); - Map readTestClusterFloatDoubleCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readFloatDoubleAttribute((ChipClusters.DoubleAttributeCallback) callback); - }, + readTestClusterFloatSingleCommandParams + ); + readTestClusterInteractionInfo.put("readFloatSingleAttribute", readTestClusterFloatSingleAttributeInteractionInfo); + Map readTestClusterFloatDoubleCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readFloatDoubleAttribute( + ( + ChipClusters.DoubleAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readTestClusterFloatDoubleCommandParams); - readTestClusterInteractionInfo.put( - "readFloatDoubleAttribute", readTestClusterFloatDoubleAttributeInteractionInfo); - Map readTestClusterOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readOctetStringAttribute((ChipClusters.OctetStringAttributeCallback) callback); - }, + readTestClusterFloatDoubleCommandParams + ); + readTestClusterInteractionInfo.put("readFloatDoubleAttribute", readTestClusterFloatDoubleAttributeInteractionInfo); + Map readTestClusterOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readOctetStringAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readOctetStringAttribute", readTestClusterOctetStringAttributeInteractionInfo); - Map readTestClusterListInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterListInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readListInt8uAttribute( - (ChipClusters.TestClusterCluster.ListInt8uAttributeCallback) callback); - }, + readTestClusterOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readOctetStringAttribute", readTestClusterOctetStringAttributeInteractionInfo); + Map readTestClusterListInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterListInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readListInt8uAttribute( + ( ChipClusters.TestClusterCluster.ListInt8uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedTestClusterClusterListInt8uAttributeCallback(), - readTestClusterListInt8uCommandParams); - readTestClusterInteractionInfo.put( - "readListInt8uAttribute", readTestClusterListInt8uAttributeInteractionInfo); - Map readTestClusterListOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterListOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readListOctetStringAttribute( - (ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTestClusterClusterListOctetStringAttributeCallback(), - readTestClusterListOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readListOctetStringAttribute", readTestClusterListOctetStringAttributeInteractionInfo); - Map readTestClusterListStructOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterListStructOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readListStructOctetStringAttribute( - (ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTestClusterClusterListStructOctetStringAttributeCallback(), - readTestClusterListStructOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readListStructOctetStringAttribute", - readTestClusterListStructOctetStringAttributeInteractionInfo); - Map readTestClusterLongOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterLongOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readLongOctetStringAttribute( - (ChipClusters.OctetStringAttributeCallback) callback); - }, + readTestClusterListInt8uCommandParams + ); + readTestClusterInteractionInfo.put("readListInt8uAttribute", readTestClusterListInt8uAttributeInteractionInfo); + Map readTestClusterListOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterListOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readListOctetStringAttribute( + ( ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTestClusterClusterListOctetStringAttributeCallback(), + readTestClusterListOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readListOctetStringAttribute", readTestClusterListOctetStringAttributeInteractionInfo); + Map readTestClusterListStructOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterListStructOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readListStructOctetStringAttribute( + ( ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTestClusterClusterListStructOctetStringAttributeCallback(), + readTestClusterListStructOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readListStructOctetStringAttribute", readTestClusterListStructOctetStringAttributeInteractionInfo); + Map readTestClusterLongOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterLongOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readLongOctetStringAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterLongOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeInteractionInfo); - Map readTestClusterCharStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readTestClusterLongOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeInteractionInfo); + Map readTestClusterCharStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readCharStringAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterCharStringCommandParams); - readTestClusterInteractionInfo.put( - "readCharStringAttribute", readTestClusterCharStringAttributeInteractionInfo); - Map readTestClusterLongCharStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterLongCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readLongCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readTestClusterCharStringCommandParams + ); + readTestClusterInteractionInfo.put("readCharStringAttribute", readTestClusterCharStringAttributeInteractionInfo); + Map readTestClusterLongCharStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterLongCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readLongCharStringAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterLongCharStringCommandParams); - readTestClusterInteractionInfo.put( - "readLongCharStringAttribute", readTestClusterLongCharStringAttributeInteractionInfo); - Map readTestClusterEpochUsCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterEpochUsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readEpochUsAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterLongCharStringCommandParams + ); + readTestClusterInteractionInfo.put("readLongCharStringAttribute", readTestClusterLongCharStringAttributeInteractionInfo); + Map readTestClusterEpochUsCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterEpochUsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readEpochUsAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterEpochUsCommandParams); - readTestClusterInteractionInfo.put( - "readEpochUsAttribute", readTestClusterEpochUsAttributeInteractionInfo); - Map readTestClusterEpochSCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterEpochSAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readEpochSAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readTestClusterEpochUsCommandParams + ); + readTestClusterInteractionInfo.put("readEpochUsAttribute", readTestClusterEpochUsAttributeInteractionInfo); + Map readTestClusterEpochSCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterEpochSAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readEpochSAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterEpochSCommandParams); - readTestClusterInteractionInfo.put( - "readEpochSAttribute", readTestClusterEpochSAttributeInteractionInfo); - Map readTestClusterVendorIdCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterVendorIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readVendorIdAttribute( - (ChipClusters.TestClusterCluster.VendorIdAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterVendorIdCommandParams); - readTestClusterInteractionInfo.put( - "readVendorIdAttribute", readTestClusterVendorIdAttributeInteractionInfo); - Map readTestClusterListNullablesAndOptionalsStructCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readListNullablesAndOptionalsStructAttribute( - (ChipClusters.TestClusterCluster - .ListNullablesAndOptionalsStructAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback(), - readTestClusterListNullablesAndOptionalsStructCommandParams); - readTestClusterInteractionInfo.put( - "readListNullablesAndOptionalsStructAttribute", - readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); - Map readTestClusterEnumAttrCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readEnumAttrAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnumAttrCommandParams); - readTestClusterInteractionInfo.put( - "readEnumAttrAttribute", readTestClusterEnumAttrAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readRangeRestrictedInt8uAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt8uCommandParams); - readTestClusterInteractionInfo.put( - "readRangeRestrictedInt8uAttribute", - readTestClusterRangeRestrictedInt8uAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readRangeRestrictedInt8sAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt8sCommandParams); - readTestClusterInteractionInfo.put( - "readRangeRestrictedInt8sAttribute", - readTestClusterRangeRestrictedInt8sAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readRangeRestrictedInt16uAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt16uCommandParams); - readTestClusterInteractionInfo.put( - "readRangeRestrictedInt16uAttribute", - readTestClusterRangeRestrictedInt16uAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readRangeRestrictedInt16sAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt16sCommandParams); - readTestClusterInteractionInfo.put( - "readRangeRestrictedInt16sAttribute", - readTestClusterRangeRestrictedInt16sAttributeInteractionInfo); - Map readTestClusterListLongOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterListLongOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readListLongOctetStringAttribute( - (ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedTestClusterClusterListLongOctetStringAttributeCallback(), - readTestClusterListLongOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readListLongOctetStringAttribute", - readTestClusterListLongOctetStringAttributeInteractionInfo); - Map readTestClusterTimedWriteBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterTimedWriteBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readTimedWriteBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readTestClusterEpochSCommandParams + ); + readTestClusterInteractionInfo.put("readEpochSAttribute", readTestClusterEpochSAttributeInteractionInfo); + Map readTestClusterVendorIdCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterVendorIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readVendorIdAttribute( + ( ChipClusters.TestClusterCluster.VendorIdAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterVendorIdCommandParams + ); + readTestClusterInteractionInfo.put("readVendorIdAttribute", readTestClusterVendorIdAttributeInteractionInfo); + Map readTestClusterListNullablesAndOptionalsStructCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readListNullablesAndOptionalsStructAttribute( + ( ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback(), + readTestClusterListNullablesAndOptionalsStructCommandParams + ); + readTestClusterInteractionInfo.put("readListNullablesAndOptionalsStructAttribute", readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); + Map readTestClusterEnumAttrCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readEnumAttrAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnumAttrCommandParams + ); + readTestClusterInteractionInfo.put("readEnumAttrAttribute", readTestClusterEnumAttrAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt8uAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8uCommandParams + ); + readTestClusterInteractionInfo.put("readRangeRestrictedInt8uAttribute", readTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt8sAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8sCommandParams + ); + readTestClusterInteractionInfo.put("readRangeRestrictedInt8sAttribute", readTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt16uAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16uCommandParams + ); + readTestClusterInteractionInfo.put("readRangeRestrictedInt16uAttribute", readTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt16sAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16sCommandParams + ); + readTestClusterInteractionInfo.put("readRangeRestrictedInt16sAttribute", readTestClusterRangeRestrictedInt16sAttributeInteractionInfo); + Map readTestClusterListLongOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterListLongOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readListLongOctetStringAttribute( + ( ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTestClusterClusterListLongOctetStringAttributeCallback(), + readTestClusterListLongOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readListLongOctetStringAttribute", readTestClusterListLongOctetStringAttributeInteractionInfo); + Map readTestClusterTimedWriteBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readTimedWriteBooleanAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterTimedWriteBooleanCommandParams); - readTestClusterInteractionInfo.put( - "readTimedWriteBooleanAttribute", readTestClusterTimedWriteBooleanAttributeInteractionInfo); - Map readTestClusterGeneralErrorBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterGeneralErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readGeneralErrorBooleanAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readTestClusterTimedWriteBooleanCommandParams + ); + readTestClusterInteractionInfo.put("readTimedWriteBooleanAttribute", readTestClusterTimedWriteBooleanAttributeInteractionInfo); + Map readTestClusterGeneralErrorBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readGeneralErrorBooleanAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterGeneralErrorBooleanCommandParams); - readTestClusterInteractionInfo.put( - "readGeneralErrorBooleanAttribute", - readTestClusterGeneralErrorBooleanAttributeInteractionInfo); - Map readTestClusterClusterErrorBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterClusterErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readClusterErrorBooleanAttribute( - (ChipClusters.BooleanAttributeCallback) callback); - }, + readTestClusterGeneralErrorBooleanCommandParams + ); + readTestClusterInteractionInfo.put("readGeneralErrorBooleanAttribute", readTestClusterGeneralErrorBooleanAttributeInteractionInfo); + Map readTestClusterClusterErrorBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readClusterErrorBooleanAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterClusterErrorBooleanCommandParams); - readTestClusterInteractionInfo.put( - "readClusterErrorBooleanAttribute", - readTestClusterClusterErrorBooleanAttributeInteractionInfo); - Map readTestClusterUnsupportedCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readUnsupportedAttribute((ChipClusters.BooleanAttributeCallback) callback); - }, + readTestClusterClusterErrorBooleanCommandParams + ); + readTestClusterInteractionInfo.put("readClusterErrorBooleanAttribute", readTestClusterClusterErrorBooleanAttributeInteractionInfo); + Map readTestClusterUnsupportedCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readUnsupportedAttribute( + ( + ChipClusters.BooleanAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterUnsupportedCommandParams); - readTestClusterInteractionInfo.put( - "readUnsupportedAttribute", readTestClusterUnsupportedAttributeInteractionInfo); - Map readTestClusterNullableBooleanCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableBooleanAttribute( - (ChipClusters.TestClusterCluster.NullableBooleanAttributeCallback) callback); - }, + readTestClusterUnsupportedCommandParams + ); + readTestClusterInteractionInfo.put("readUnsupportedAttribute", readTestClusterUnsupportedAttributeInteractionInfo); + Map readTestClusterNullableBooleanCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableBooleanAttribute( + ( ChipClusters.TestClusterCluster.NullableBooleanAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterNullableBooleanCommandParams); - readTestClusterInteractionInfo.put( - "readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeInteractionInfo); - Map readTestClusterNullableBitmap8CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableBitmap8Attribute( - (ChipClusters.TestClusterCluster.NullableBitmap8AttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableBitmap8CommandParams); - readTestClusterInteractionInfo.put( - "readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeInteractionInfo); - Map readTestClusterNullableBitmap16CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableBitmap16Attribute( - (ChipClusters.TestClusterCluster.NullableBitmap16AttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableBitmap16CommandParams); - readTestClusterInteractionInfo.put( - "readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeInteractionInfo); - Map readTestClusterNullableBitmap32CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableBitmap32Attribute( - (ChipClusters.TestClusterCluster.NullableBitmap32AttributeCallback) callback); - }, + readTestClusterNullableBooleanCommandParams + ); + readTestClusterInteractionInfo.put("readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeInteractionInfo); + Map readTestClusterNullableBitmap8CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap8Attribute( + ( ChipClusters.TestClusterCluster.NullableBitmap8AttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableBitmap8CommandParams + ); + readTestClusterInteractionInfo.put("readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeInteractionInfo); + Map readTestClusterNullableBitmap16CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap16Attribute( + ( ChipClusters.TestClusterCluster.NullableBitmap16AttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableBitmap16CommandParams + ); + readTestClusterInteractionInfo.put("readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeInteractionInfo); + Map readTestClusterNullableBitmap32CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap32Attribute( + ( ChipClusters.TestClusterCluster.NullableBitmap32AttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableBitmap32CommandParams); - readTestClusterInteractionInfo.put( - "readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeInteractionInfo); - Map readTestClusterNullableBitmap64CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableBitmap64Attribute( - (ChipClusters.TestClusterCluster.NullableBitmap64AttributeCallback) callback); - }, + readTestClusterNullableBitmap32CommandParams + ); + readTestClusterInteractionInfo.put("readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeInteractionInfo); + Map readTestClusterNullableBitmap64CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap64Attribute( + ( ChipClusters.TestClusterCluster.NullableBitmap64AttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableBitmap64CommandParams); - readTestClusterInteractionInfo.put( - "readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeInteractionInfo); - Map readTestClusterNullableInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt8uAttribute( - (ChipClusters.TestClusterCluster.NullableInt8uAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt8uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeInteractionInfo); - Map readTestClusterNullableInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt16uAttribute( - (ChipClusters.TestClusterCluster.NullableInt16uAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt16uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); - Map readTestClusterNullableInt24uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt24uAttribute( - (ChipClusters.TestClusterCluster.NullableInt24uAttributeCallback) callback); - }, + readTestClusterNullableBitmap64CommandParams + ); + readTestClusterInteractionInfo.put("readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeInteractionInfo); + Map readTestClusterNullableInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt8uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt8uAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt8uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeInteractionInfo); + Map readTestClusterNullableInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt16uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt16uAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt16uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); + Map readTestClusterNullableInt24uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt24uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt24uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt24uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt24uAttribute", readTestClusterNullableInt24uAttributeInteractionInfo); - Map readTestClusterNullableInt32uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt32uAttribute( - (ChipClusters.TestClusterCluster.NullableInt32uAttributeCallback) callback); - }, + readTestClusterNullableInt24uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt24uAttribute", readTestClusterNullableInt24uAttributeInteractionInfo); + Map readTestClusterNullableInt32uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt32uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt32uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt32uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); - Map readTestClusterNullableInt40uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt40uAttribute( - (ChipClusters.TestClusterCluster.NullableInt40uAttributeCallback) callback); - }, + readTestClusterNullableInt32uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); + Map readTestClusterNullableInt40uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt40uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt40uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt40uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt40uAttribute", readTestClusterNullableInt40uAttributeInteractionInfo); - Map readTestClusterNullableInt48uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt48uAttribute( - (ChipClusters.TestClusterCluster.NullableInt48uAttributeCallback) callback); - }, + readTestClusterNullableInt40uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt40uAttribute", readTestClusterNullableInt40uAttributeInteractionInfo); + Map readTestClusterNullableInt48uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt48uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt48uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt48uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt48uAttribute", readTestClusterNullableInt48uAttributeInteractionInfo); - Map readTestClusterNullableInt56uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt56uAttribute( - (ChipClusters.TestClusterCluster.NullableInt56uAttributeCallback) callback); - }, + readTestClusterNullableInt48uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt48uAttribute", readTestClusterNullableInt48uAttributeInteractionInfo); + Map readTestClusterNullableInt56uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt56uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt56uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt56uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt56uAttribute", readTestClusterNullableInt56uAttributeInteractionInfo); - Map readTestClusterNullableInt64uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt64uAttribute( - (ChipClusters.TestClusterCluster.NullableInt64uAttributeCallback) callback); - }, + readTestClusterNullableInt56uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt56uAttribute", readTestClusterNullableInt56uAttributeInteractionInfo); + Map readTestClusterNullableInt64uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt64uAttribute( + ( ChipClusters.TestClusterCluster.NullableInt64uAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt64uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeInteractionInfo); - Map readTestClusterNullableInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt8sAttribute( - (ChipClusters.TestClusterCluster.NullableInt8sAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt8sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeInteractionInfo); - Map readTestClusterNullableInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt16sAttribute( - (ChipClusters.TestClusterCluster.NullableInt16sAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt16sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); - Map readTestClusterNullableInt24sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt24sAttribute( - (ChipClusters.TestClusterCluster.NullableInt24sAttributeCallback) callback); - }, + readTestClusterNullableInt64uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeInteractionInfo); + Map readTestClusterNullableInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt8sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt8sAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt8sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeInteractionInfo); + Map readTestClusterNullableInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt16sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt16sAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt16sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); + Map readTestClusterNullableInt24sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt24sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt24sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt24sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt24sAttribute", readTestClusterNullableInt24sAttributeInteractionInfo); - Map readTestClusterNullableInt32sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt32sAttribute( - (ChipClusters.TestClusterCluster.NullableInt32sAttributeCallback) callback); - }, + readTestClusterNullableInt24sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt24sAttribute", readTestClusterNullableInt24sAttributeInteractionInfo); + Map readTestClusterNullableInt32sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt32sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt32sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt32sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); - Map readTestClusterNullableInt40sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt40sAttribute( - (ChipClusters.TestClusterCluster.NullableInt40sAttributeCallback) callback); - }, + readTestClusterNullableInt32sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); + Map readTestClusterNullableInt40sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt40sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt40sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt40sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt40sAttribute", readTestClusterNullableInt40sAttributeInteractionInfo); - Map readTestClusterNullableInt48sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt48sAttribute( - (ChipClusters.TestClusterCluster.NullableInt48sAttributeCallback) callback); - }, + readTestClusterNullableInt40sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt40sAttribute", readTestClusterNullableInt40sAttributeInteractionInfo); + Map readTestClusterNullableInt48sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt48sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt48sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt48sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt48sAttribute", readTestClusterNullableInt48sAttributeInteractionInfo); - Map readTestClusterNullableInt56sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt56sAttribute( - (ChipClusters.TestClusterCluster.NullableInt56sAttributeCallback) callback); - }, + readTestClusterNullableInt48sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt48sAttribute", readTestClusterNullableInt48sAttributeInteractionInfo); + Map readTestClusterNullableInt56sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt56sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt56sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt56sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt56sAttribute", readTestClusterNullableInt56sAttributeInteractionInfo); - Map readTestClusterNullableInt64sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableInt64sAttribute( - (ChipClusters.TestClusterCluster.NullableInt64sAttributeCallback) callback); - }, + readTestClusterNullableInt56sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt56sAttribute", readTestClusterNullableInt56sAttributeInteractionInfo); + Map readTestClusterNullableInt64sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableInt64sAttribute( + ( ChipClusters.TestClusterCluster.NullableInt64sAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt64sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeInteractionInfo); - Map readTestClusterNullableEnum8CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableEnum8Attribute( - (ChipClusters.TestClusterCluster.NullableEnum8AttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnum8CommandParams); - readTestClusterInteractionInfo.put( - "readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeInteractionInfo); - Map readTestClusterNullableEnum16CommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableEnum16Attribute( - (ChipClusters.TestClusterCluster.NullableEnum16AttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnum16CommandParams); - readTestClusterInteractionInfo.put( - "readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); - Map readTestClusterNullableFloatSingleCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableFloatSingleAttribute( - (ChipClusters.TestClusterCluster.NullableFloatSingleAttributeCallback) - callback); - }, + readTestClusterNullableInt64sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeInteractionInfo); + Map readTestClusterNullableEnum8CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableEnum8Attribute( + ( ChipClusters.TestClusterCluster.NullableEnum8AttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnum8CommandParams + ); + readTestClusterInteractionInfo.put("readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeInteractionInfo); + Map readTestClusterNullableEnum16CommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableEnum16Attribute( + ( ChipClusters.TestClusterCluster.NullableEnum16AttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnum16CommandParams + ); + readTestClusterInteractionInfo.put("readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); + Map readTestClusterNullableFloatSingleCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableFloatSingleAttribute( + ( ChipClusters.TestClusterCluster.NullableFloatSingleAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readTestClusterNullableFloatSingleCommandParams); - readTestClusterInteractionInfo.put( - "readNullableFloatSingleAttribute", - readTestClusterNullableFloatSingleAttributeInteractionInfo); - Map readTestClusterNullableFloatDoubleCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableFloatDoubleAttribute( - (ChipClusters.TestClusterCluster.NullableFloatDoubleAttributeCallback) - callback); - }, + readTestClusterNullableFloatSingleCommandParams + ); + readTestClusterInteractionInfo.put("readNullableFloatSingleAttribute", readTestClusterNullableFloatSingleAttributeInteractionInfo); + Map readTestClusterNullableFloatDoubleCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableFloatDoubleAttribute( + ( ChipClusters.TestClusterCluster.NullableFloatDoubleAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readTestClusterNullableFloatDoubleCommandParams); - readTestClusterInteractionInfo.put( - "readNullableFloatDoubleAttribute", - readTestClusterNullableFloatDoubleAttributeInteractionInfo); - Map readTestClusterNullableOctetStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableOctetStringAttribute( - (ChipClusters.TestClusterCluster.NullableOctetStringAttributeCallback) - callback); - }, + readTestClusterNullableFloatDoubleCommandParams + ); + readTestClusterInteractionInfo.put("readNullableFloatDoubleAttribute", readTestClusterNullableFloatDoubleAttributeInteractionInfo); + Map readTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableOctetStringAttribute( + ( ChipClusters.TestClusterCluster.NullableOctetStringAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterNullableOctetStringCommandParams); - readTestClusterInteractionInfo.put( - "readNullableOctetStringAttribute", - readTestClusterNullableOctetStringAttributeInteractionInfo); - Map readTestClusterNullableCharStringCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableCharStringAttribute( - (ChipClusters.TestClusterCluster.NullableCharStringAttributeCallback) - callback); - }, + readTestClusterNullableOctetStringCommandParams + ); + readTestClusterInteractionInfo.put("readNullableOctetStringAttribute", readTestClusterNullableOctetStringAttributeInteractionInfo); + Map readTestClusterNullableCharStringCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableCharStringAttribute( + ( ChipClusters.TestClusterCluster.NullableCharStringAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterNullableCharStringCommandParams); - readTestClusterInteractionInfo.put( - "readNullableCharStringAttribute", - readTestClusterNullableCharStringAttributeInteractionInfo); - Map readTestClusterNullableEnumAttrCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableEnumAttrAttribute( - (ChipClusters.TestClusterCluster.NullableEnumAttrAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnumAttrCommandParams); - readTestClusterInteractionInfo.put( - "readNullableEnumAttrAttribute", readTestClusterNullableEnumAttrAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableRangeRestrictedInt8uAttribute( - (ChipClusters.TestClusterCluster - .NullableRangeRestrictedInt8uAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt8uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableRangeRestrictedInt8uAttribute", - readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableRangeRestrictedInt8sAttribute( - (ChipClusters.TestClusterCluster - .NullableRangeRestrictedInt8sAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt8sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableRangeRestrictedInt8sAttribute", - readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableRangeRestrictedInt16uAttribute( - (ChipClusters.TestClusterCluster - .NullableRangeRestrictedInt16uAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt16uCommandParams); - readTestClusterInteractionInfo.put( - "readNullableRangeRestrictedInt16uAttribute", - readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readNullableRangeRestrictedInt16sAttribute( - (ChipClusters.TestClusterCluster - .NullableRangeRestrictedInt16sAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt16sCommandParams); - readTestClusterInteractionInfo.put( - "readNullableRangeRestrictedInt16sAttribute", - readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); - Map readTestClusterAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.TestClusterCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping.DelegatedTestClusterClusterAttributeListAttributeCallback(), - readTestClusterAttributeListCommandParams); - readTestClusterInteractionInfo.put( - "readAttributeListAttribute", readTestClusterAttributeListAttributeInteractionInfo); - Map readTestClusterClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterClusterRevisionCommandParams); - readTestClusterInteractionInfo.put( - "readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("testCluster", readTestClusterInteractionInfo); - Map readThermostatInteractionInfo = new LinkedHashMap<>(); - Map readThermostatLocalTemperatureCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readLocalTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatLocalTemperatureCommandParams); - readThermostatInteractionInfo.put( - "readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); - Map readThermostatAbsMinHeatSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readAbsMinHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMinHeatSetpointLimitCommandParams); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readAbsMaxCoolSetpointLimitAttribute", - readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatOccupiedCoolingSetpointCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readOccupiedCoolingSetpointAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatOccupiedCoolingSetpointCommandParams); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readOccupiedHeatingSetpointAttribute", - readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); - Map readThermostatMinHeatSetpointLimitCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readMinHeatSetpointLimitAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMinHeatSetpointLimitCommandParams); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readMinSetpointDeadBandAttribute", - readThermostatMinSetpointDeadBandAttributeInteractionInfo); - Map readThermostatControlSequenceOfOperationCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readControlSequenceOfOperationAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatControlSequenceOfOperationCommandParams); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); - Map readThermostatStartOfWeekCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readStartOfWeekAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatStartOfWeekCommandParams); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readNumberOfDailyTransitionsAttribute", - readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); - Map readThermostatAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ThermostatCluster.AttributeListAttributeCallback) callback); - }, + readTestClusterNullableCharStringCommandParams + ); + readTestClusterInteractionInfo.put("readNullableCharStringAttribute", readTestClusterNullableCharStringAttributeInteractionInfo); + Map readTestClusterNullableEnumAttrCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableEnumAttrAttribute( + ( ChipClusters.TestClusterCluster.NullableEnumAttrAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnumAttrCommandParams + ); + readTestClusterInteractionInfo.put("readNullableEnumAttrAttribute", readTestClusterNullableEnumAttrAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt8uAttribute( + ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt8uAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt8uAttribute", readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt8sAttribute( + ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt8sAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt8sAttribute", readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt16uAttribute( + ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt16uAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16uCommandParams + ); + readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt16uAttribute", readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt16sAttribute( + ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt16sAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16sCommandParams + ); + readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt16sAttribute", readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); + Map readTestClusterAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readAttributeListAttribute( + ( ChipClusters.TestClusterCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedTestClusterClusterAttributeListAttributeCallback(), + readTestClusterAttributeListCommandParams + ); + readTestClusterInteractionInfo.put("readAttributeListAttribute", readTestClusterAttributeListAttributeInteractionInfo); + Map readTestClusterClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterClusterRevisionCommandParams + ); + readTestClusterInteractionInfo.put("readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("testCluster", readTestClusterInteractionInfo); + Map readThermostatInteractionInfo = new LinkedHashMap<>(); + Map readThermostatLocalTemperatureCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readLocalTemperatureAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatLocalTemperatureCommandParams + ); + readThermostatInteractionInfo.put("readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); + Map readThermostatAbsMinHeatSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readAbsMinHeatSetpointLimitAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMinHeatSetpointLimitCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readAbsMaxCoolSetpointLimitAttribute", readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readOccupiedCoolingSetpointAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatOccupiedCoolingSetpointCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readOccupiedHeatingSetpointAttribute", readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); + Map readThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readMinHeatSetpointLimitAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMinHeatSetpointLimitCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readMinSetpointDeadBandAttribute", readThermostatMinSetpointDeadBandAttributeInteractionInfo); + Map readThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readControlSequenceOfOperationAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatControlSequenceOfOperationCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); + Map readThermostatStartOfWeekCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readStartOfWeekAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatStartOfWeekCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readNumberOfDailyTransitionsAttribute", readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); + Map readThermostatAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ThermostatCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedThermostatClusterAttributeListAttributeCallback(), - readThermostatAttributeListCommandParams); - readThermostatInteractionInfo.put( - "readAttributeListAttribute", readThermostatAttributeListAttributeInteractionInfo); - Map readThermostatFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThermostatAttributeListCommandParams + ); + readThermostatInteractionInfo.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); - readThermostatInteractionInfo.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); - readThermostatInteractionInfo.put( - "readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("thermostat", readThermostatInteractionInfo); - Map readThermostatUserInterfaceConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map - readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = - new LinkedHashMap(); - InteractionInfo - readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readTemperatureDisplayModeAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams); - readThermostatUserInterfaceConfigurationInteractionInfo.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); - readThermostatUserInterfaceConfigurationInteractionInfo.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); - readThermostatUserInterfaceConfigurationInteractionInfo.put( - "readScheduleProgrammingVisibilityAttribute", - readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ThermostatUserInterfaceConfigurationCluster - .AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), - readThermostatUserInterfaceConfigurationAttributeListCommandParams); - readThermostatUserInterfaceConfigurationInteractionInfo.put( - "readAttributeListAttribute", - readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); - Map - readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo - readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) - .readClusterRevisionAttribute( - (ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationClusterRevisionCommandParams); - readThermostatUserInterfaceConfigurationInteractionInfo.put( - "readClusterRevisionAttribute", - readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put( - "thermostatUserInterfaceConfiguration", - readThermostatUserInterfaceConfigurationInteractionInfo); - Map readThreadNetworkDiagnosticsInteractionInfo = - new LinkedHashMap<>(); - Map readThreadNetworkDiagnosticsChannelCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readChannelAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsChannelCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRoutingRoleAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsRoutingRoleCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRoutingRoleAttribute", - readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNetworkNameCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readNetworkNameAttribute((ChipClusters.CharStringAttributeCallback) callback); - }, + readThermostatFeatureMapCommandParams + ); + readThermostatInteractionInfo.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 + ); + readThermostatInteractionInfo.put("readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("thermostat", readThermostatInteractionInfo); + Map readThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); + Map readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readTemperatureDisplayModeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams + ); + readThermostatUserInterfaceConfigurationInteractionInfo.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 + ); + readThermostatUserInterfaceConfigurationInteractionInfo.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 + ); + readThermostatUserInterfaceConfigurationInteractionInfo.put("readScheduleProgrammingVisibilityAttribute", readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ThermostatUserInterfaceConfigurationCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), + readThermostatUserInterfaceConfigurationAttributeListCommandParams + ); + readThermostatUserInterfaceConfigurationInteractionInfo.put("readAttributeListAttribute", readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); + Map readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams + ); + readThermostatUserInterfaceConfigurationInteractionInfo.put("readClusterRevisionAttribute", readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("thermostatUserInterfaceConfiguration", readThermostatUserInterfaceConfigurationInteractionInfo); + Map readThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + Map readThreadNetworkDiagnosticsChannelCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsChannelCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRoutingRoleAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsRoutingRoleCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRoutingRoleAttribute", readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNetworkNameCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNetworkNameAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readThreadNetworkDiagnosticsNetworkNameCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readNetworkNameAttribute", - readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPanIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readPanIdAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsPanIdCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readExtendedPanIdAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsNetworkNameCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readNetworkNameAttribute", readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPanIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPanIdAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsPanIdCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readExtendedPanIdAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsExtendedPanIdCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readExtendedPanIdAttribute", - readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readMeshLocalPrefixAttribute( - (ChipClusters.OctetStringAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsExtendedPanIdCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readExtendedPanIdAttribute", readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readMeshLocalPrefixAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readMeshLocalPrefixAttribute", - readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsOverrunCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readOverrunCountAttribute", - readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNeighborTableListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readNeighborTableListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .NeighborTableListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback(), - readThreadNetworkDiagnosticsNeighborTableListCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readNeighborTableListAttribute", - readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRouteTableListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRouteTableListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback(), - readThreadNetworkDiagnosticsRouteTableListCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRouteTableListAttribute", - readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPartitionIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readPartitionIdAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsOverrunCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNeighborTableListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNeighborTableListAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback(), + readThreadNetworkDiagnosticsNeighborTableListCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readNeighborTableListAttribute", readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRouteTableListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRouteTableListAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback(), + readThreadNetworkDiagnosticsRouteTableListCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRouteTableListAttribute", readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPartitionIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPartitionIdAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsPartitionIdCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readPartitionIdAttribute", - readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsWeightingCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readWeightingAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsWeightingCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDataVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsDataVersionCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readDataVersionAttribute", - readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readStableDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsStableDataVersionCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readStableDataVersionAttribute", - readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readLeaderRouterIdAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsLeaderRouterIdCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readParentChangeCountAttribute", - readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxTotalCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsPartitionIdCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readPartitionIdAttribute", readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsWeightingCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readWeightingAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsWeightingCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDataVersionCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDataVersionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsDataVersionCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readDataVersionAttribute", readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readStableDataVersionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsStableDataVersionCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readStableDataVersionAttribute", readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readLeaderRouterIdAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsLeaderRouterIdCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxTotalCountAttribute", - readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxUnicastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxTotalCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxUnicastCountAttribute", - readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBroadcastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxUnicastCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxBroadcastCountAttribute", - readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxAckRequestedCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxBroadcastCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxAckRequestedCountAttribute", - readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxAckedCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxAckedCountAttribute", - readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxNoAckRequestedCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxAckedCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxNoAckRequestedCountAttribute", - readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxDataCountAttribute", - readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataPollCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxDataCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxDataPollCountAttribute", - readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBeaconCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxDataPollCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxBeaconCountAttribute", - readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxBeaconCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxBeaconRequestCountAttribute", - readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxOtherCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxOtherCountAttribute", - readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxRetryCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxRetryCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxOtherCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxIndirectMaxRetryExpiryCountAttribute", - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxErrCcaCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxRetryCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxRetryCountAttribute", readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDirectMaxRetryExpiryCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrCcaCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxErrCcaCountAttribute", - readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxErrAbortCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxDirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxIndirectMaxRetryExpiryCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrAbortCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxErrAbortCountAttribute", - readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readTxErrBusyChannelCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxIndirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrCcaCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readTxErrBusyChannelCountAttribute", - readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxErrCcaCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrCcaCountAttribute", readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrAbortCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxTotalCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxTotalCountAttribute", - readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxErrAbortCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrAbortCountAttribute", readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrBusyChannelCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxUnicastCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxUnicastCountAttribute", - readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrBusyChannelCountAttribute", readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxTotalCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBroadcastCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxBroadcastCountAttribute", - readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxTotalCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxTotalCountAttribute", readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxUnicastCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxDataCountAttribute", - readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxUnicastCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxUnicastCountAttribute", readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBroadcastCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataPollCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxDataPollCountAttribute", - readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxBroadcastCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxBroadcastCountAttribute", readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxBeaconCountAttribute", - readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxDataCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxDataCountAttribute", readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataPollCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxBeaconRequestCountAttribute", - readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxDataPollCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxDataPollCountAttribute", readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxOtherCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxOtherCountAttribute", - readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxAddressFilteredCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxBeaconCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxBeaconCountAttribute", readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconRequestCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxAddressFilteredCountAttribute", - readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDestAddrFilteredCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxOtherCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxDestAddrFilteredCountAttribute", - readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxDuplicatedCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxOtherCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxOtherCountAttribute", readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxAddressFilteredCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxDuplicatedCountAttribute", - readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrNoFrameCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxAddressFilteredCountAttribute", readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDestAddrFilteredCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrNoFrameCountAttribute", - readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrUnknownNeighborCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxDestAddrFilteredCountAttribute", readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDuplicatedCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrUnknownNeighborCountAttribute", - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrInvalidSrcAddrCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxDuplicatedCountAttribute", readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrNoFrameCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrInvalidSrcAddrCountAttribute", - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrSecCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrNoFrameCountAttribute", readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrUnknownNeighborCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrSecCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrSecCountAttribute", - readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrFcsCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrUnknownNeighborCountAttribute", readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrInvalidSrcAddrCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrFcsCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrFcsCountAttribute", - readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readRxErrOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrInvalidSrcAddrCountAttribute", readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrSecCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrOtherCountCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readRxErrOtherCountAttribute", - readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readActiveTimestampAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrSecCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrSecCountAttribute", readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrFcsCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsActiveTimestampCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readActiveTimestampAttribute", - readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readPendingTimestampAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrFcsCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrFcsCountAttribute", readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrOtherCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsPendingTimestampCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readPendingTimestampAttribute", - readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDelayCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readDelayAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsRxErrOtherCountCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrOtherCountAttribute", readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveTimestampAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsDelayCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsSecurityPolicyCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readSecurityPolicyAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback(), - readThreadNetworkDiagnosticsSecurityPolicyCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readSecurityPolicyAttribute", - readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsChannelMaskCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readChannelMaskAttribute((ChipClusters.OctetStringAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsActiveTimestampCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readActiveTimestampAttribute", readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPendingTimestampAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsPendingTimestampCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readPendingTimestampAttribute", readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDelayCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDelayAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), + readThreadNetworkDiagnosticsDelayCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsSecurityPolicyCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readSecurityPolicyAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback(), + readThreadNetworkDiagnosticsSecurityPolicyCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readSecurityPolicyAttribute", readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsChannelMaskCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelMaskAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readThreadNetworkDiagnosticsChannelMaskCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readChannelMaskAttribute", - readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams = - new LinkedHashMap(); - InteractionInfo - readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readOperationalDatasetComponentsAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .OperationalDatasetComponentsAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback(), - readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readOperationalDatasetComponentsAttribute", - readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo); - Map - readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readActiveNetworkFaultsListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster - .ActiveNetworkFaultsListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), - readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readActiveNetworkFaultsListAttribute", - readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readThreadNetworkDiagnosticsAttributeListCommandParams); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readAttributeListAttribute", - readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsChannelMaskCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readChannelMaskAttribute", readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readOperationalDatasetComponentsAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.OperationalDatasetComponentsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback(), + readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readOperationalDatasetComponentsAttribute", readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveNetworkFaultsListAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), + readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readActiveNetworkFaultsListAttribute", readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readThreadNetworkDiagnosticsAttributeListCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.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); - readThreadNetworkDiagnosticsInteractionInfo.put( - "readClusterRevisionAttribute", - readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo); - Map readTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map readTimeFormatLocalizationHourFormatCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readHourFormatAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationHourFormatCommandParams); - readTimeFormatLocalizationInteractionInfo.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); - readTimeFormatLocalizationInteractionInfo.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); - readTimeFormatLocalizationInteractionInfo.put( - "readSupportedCalendarTypesAttribute", - readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); - Map readTimeFormatLocalizationClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationClusterRevisionCommandParams); - readTimeFormatLocalizationInteractionInfo.put( - "readClusterRevisionAttribute", - readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo); - Map readUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map readUnitLocalizationTemperatureUnitCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .readTemperatureUnitAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitLocalizationTemperatureUnitCommandParams); - readUnitLocalizationInteractionInfo.put( - "readTemperatureUnitAttribute", - readUnitLocalizationTemperatureUnitAttributeInteractionInfo); - Map readUnitLocalizationFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readThreadNetworkDiagnosticsFeatureMapCommandParams + ); + readThreadNetworkDiagnosticsInteractionInfo.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 + ); + readThreadNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo); + Map readTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); + Map readTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readHourFormatAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationHourFormatCommandParams + ); + readTimeFormatLocalizationInteractionInfo.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 + ); + readTimeFormatLocalizationInteractionInfo.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 + ); + readTimeFormatLocalizationInteractionInfo.put("readSupportedCalendarTypesAttribute", readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); + Map readTimeFormatLocalizationClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationClusterRevisionCommandParams + ); + readTimeFormatLocalizationInteractionInfo.put("readClusterRevisionAttribute", readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo); + Map readUnitLocalizationInteractionInfo = new LinkedHashMap<>(); + Map readUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); + InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).readTemperatureUnitAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitLocalizationTemperatureUnitCommandParams + ); + readUnitLocalizationInteractionInfo.put("readTemperatureUnitAttribute", readUnitLocalizationTemperatureUnitAttributeInteractionInfo); + Map readUnitLocalizationFeatureMapCommandParams = new LinkedHashMap(); + InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster).readFeatureMapAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitLocalizationFeatureMapCommandParams); - readUnitLocalizationInteractionInfo.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); - readUnitLocalizationInteractionInfo.put( - "readClusterRevisionAttribute", - readUnitLocalizationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("unitLocalization", readUnitLocalizationInteractionInfo); - Map readUserLabelInteractionInfo = new LinkedHashMap<>(); - Map readUserLabelLabelListCommandParams = - new LinkedHashMap(); - InteractionInfo readUserLabelLabelListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster) - .readLabelListAttribute( - (ChipClusters.UserLabelCluster.LabelListAttributeCallback) callback); - }, + readUnitLocalizationFeatureMapCommandParams + ); + readUnitLocalizationInteractionInfo.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 + ); + readUnitLocalizationInteractionInfo.put("readClusterRevisionAttribute", readUnitLocalizationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("unitLocalization", readUnitLocalizationInteractionInfo); + Map readUserLabelInteractionInfo = 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); - readUserLabelInteractionInfo.put( - "readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); - Map readUserLabelClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUserLabelClusterRevisionCommandParams); - readUserLabelInteractionInfo.put( - "readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("userLabel", readUserLabelInteractionInfo); - Map readWakeOnLanInteractionInfo = new LinkedHashMap<>(); - Map readWakeOnLanWakeOnLanMacAddressCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readWakeOnLanMacAddressAttribute( - (ChipClusters.CharStringAttributeCallback) callback); - }, + readUserLabelLabelListCommandParams + ); + readUserLabelInteractionInfo.put("readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); + Map readUserLabelClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUserLabelClusterRevisionCommandParams + ); + readUserLabelInteractionInfo.put("readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("userLabel", readUserLabelInteractionInfo); + Map readWakeOnLanInteractionInfo = new LinkedHashMap<>(); + Map readWakeOnLanWakeOnLanMacAddressCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readWakeOnLanMacAddressAttribute( + ( + ChipClusters.CharStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readWakeOnLanWakeOnLanMacAddressCommandParams); - readWakeOnLanInteractionInfo.put( - "readWakeOnLanMacAddressAttribute", - readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo); - Map readWakeOnLanAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback) callback); - }, + readWakeOnLanWakeOnLanMacAddressCommandParams + ); + readWakeOnLanInteractionInfo.put("readWakeOnLanMacAddressAttribute", readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo); + Map readWakeOnLanAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readAttributeListAttribute( + ( ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback + ) callback + ); + }, () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterAttributeListAttributeCallback(), - readWakeOnLanAttributeListCommandParams); - readWakeOnLanInteractionInfo.put( - "readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); - Map readWakeOnLanClusterRevisionCommandParams = - new LinkedHashMap(); - InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster) - .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWakeOnLanClusterRevisionCommandParams); - readWakeOnLanInteractionInfo.put( - "readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("wakeOnLan", readWakeOnLanInteractionInfo); - Map readWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - Map readWiFiNetworkDiagnosticsBssidCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readBssidAttribute((ChipClusters.OctetStringAttributeCallback) callback); - }, + readWakeOnLanAttributeListCommandParams + ); + readWakeOnLanInteractionInfo.put("readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); + Map readWakeOnLanClusterRevisionCommandParams = new LinkedHashMap(); + InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster).readClusterRevisionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWakeOnLanClusterRevisionCommandParams + ); + readWakeOnLanInteractionInfo.put("readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wakeOnLan", readWakeOnLanInteractionInfo); + Map readWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + Map readWiFiNetworkDiagnosticsBssidCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBssidAttribute( + ( + ChipClusters.OctetStringAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readWiFiNetworkDiagnosticsBssidCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readSecurityTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsSecurityTypeCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readSecurityTypeAttribute", - readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readWiFiVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsWiFiVersionCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readChannelNumberAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsChannelNumberCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readChannelNumberAttribute", - readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsRssiCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readRssiAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsRssiCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readBeaconLostCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsBssidCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readSecurityTypeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsSecurityTypeCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readSecurityTypeAttribute", readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readWiFiVersionAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsWiFiVersionCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readChannelNumberAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsChannelNumberCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readChannelNumberAttribute", readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsRssiCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readRssiAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsRssiCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconLostCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconLostCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readBeaconLostCountAttribute", - readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readBeaconRxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsBeaconLostCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readBeaconLostCountAttribute", readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconRxCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconRxCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readBeaconRxCountAttribute", - readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); - Map - readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketMulticastRxCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsBeaconRxCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readBeaconRxCountAttribute", readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastRxCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readPacketMulticastRxCountAttribute", - readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); - Map - readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketMulticastTxCountAttribute( - (ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketMulticastRxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastTxCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readPacketMulticastTxCountAttribute", - readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketUnicastRxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketMulticastTxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastRxCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readPacketUnicastRxCountAttribute", - readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readPacketUnicastTxCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketUnicastRxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastTxCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readPacketUnicastTxCountAttribute", - readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readCurrentMaxRateAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketUnicastTxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readCurrentMaxRateAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readCurrentMaxRateAttribute", - readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readCurrentMaxRateAttribute", readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( + ( + ChipClusters.LongAttributeCallback +) callback + ); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsOverrunCountCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readOverrunCountAttribute", - readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback) - callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readWiFiNetworkDiagnosticsAttributeListCommandParams); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readAttributeListAttribute", - readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsOverrunCountCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( + ( ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readWiFiNetworkDiagnosticsAttributeListCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.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); - readWiFiNetworkDiagnosticsInteractionInfo.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); - readWiFiNetworkDiagnosticsInteractionInfo.put( - "readClusterRevisionAttribute", - readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo); - Map readWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map readWindowCoveringTypeCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTypeCommandParams); - readWindowCoveringInteractionInfo.put( - "readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionLiftAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftCommandParams); - readWindowCoveringInteractionInfo.put( - "readCurrentPositionLiftAttribute", - readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionTiltAttribute( - (ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltCommandParams); - readWindowCoveringInteractionInfo.put( - "readCurrentPositionTiltAttribute", - readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); - Map readWindowCoveringConfigStatusCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readConfigStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringConfigStatusCommandParams); - readWindowCoveringInteractionInfo.put( - "readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionLiftPercentageAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionLiftPercentageAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercentageCommandParams); - readWindowCoveringInteractionInfo.put( - "readCurrentPositionLiftPercentageAttribute", - readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionTiltPercentageAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionTiltPercentageAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercentageCommandParams); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.put( - "readOperationalStatusAttribute", - readWindowCoveringOperationalStatusAttributeInteractionInfo); - Map - readWindowCoveringTargetPositionLiftPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readTargetPositionLiftPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .TargetPositionLiftPercent100thsAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTargetPositionLiftPercent100thsCommandParams); - readWindowCoveringInteractionInfo.put( - "readTargetPositionLiftPercent100thsAttribute", - readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); - Map - readWindowCoveringTargetPositionTiltPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readTargetPositionTiltPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .TargetPositionTiltPercent100thsAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTargetPositionTiltPercent100thsCommandParams); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.put( - "readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); - Map - readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionLiftPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionLiftPercent100thsAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercent100thsCommandParams); - readWindowCoveringInteractionInfo.put( - "readCurrentPositionLiftPercent100thsAttribute", - readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); - Map - readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readCurrentPositionTiltPercent100thsAttribute( - (ChipClusters.WindowCoveringCluster - .CurrentPositionTiltPercent100thsAttributeCallback) - callback); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercent100thsCommandParams); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.put( - "readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); - Map readWindowCoveringAttributeListCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readAttributeListAttribute( - (ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback) callback); - }, - () -> - new ClusterInfoMapping - .DelegatedWindowCoveringClusterAttributeListAttributeCallback(), - readWindowCoveringAttributeListCommandParams); - readWindowCoveringInteractionInfo.put( - "readAttributeListAttribute", readWindowCoveringAttributeListAttributeInteractionInfo); - Map readWindowCoveringFeatureMapCommandParams = - new LinkedHashMap(); - InteractionInfo readWindowCoveringFeatureMapAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); - }, + readWiFiNetworkDiagnosticsFeatureMapCommandParams + ); + readWiFiNetworkDiagnosticsInteractionInfo.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 + ); + readWiFiNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo); + Map readWindowCoveringInteractionInfo = new LinkedHashMap<>(); + Map readWindowCoveringTypeCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readTypeAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTypeCommandParams + ); + readWindowCoveringInteractionInfo.put("readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftCommandParams + ); + readWindowCoveringInteractionInfo.put("readCurrentPositionLiftAttribute", readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltCommandParams + ); + readWindowCoveringInteractionInfo.put("readCurrentPositionTiltAttribute", readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); + Map readWindowCoveringConfigStatusCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readConfigStatusAttribute( + ( + ChipClusters.IntegerAttributeCallback +) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringConfigStatusCommandParams + ); + readWindowCoveringInteractionInfo.put("readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercentageAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercentageAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercentageCommandParams + ); + readWindowCoveringInteractionInfo.put("readCurrentPositionLiftPercentageAttribute", readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercentageAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercentageAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercentageCommandParams + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.put("readOperationalStatusAttribute", readWindowCoveringOperationalStatusAttributeInteractionInfo); + Map readWindowCoveringTargetPositionLiftPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionLiftPercent100thsAttribute( + ( ChipClusters.WindowCoveringCluster.TargetPositionLiftPercent100thsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTargetPositionLiftPercent100thsCommandParams + ); + readWindowCoveringInteractionInfo.put("readTargetPositionLiftPercent100thsAttribute", readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); + Map readWindowCoveringTargetPositionTiltPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionTiltPercent100thsAttribute( + ( ChipClusters.WindowCoveringCluster.TargetPositionTiltPercent100thsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTargetPositionTiltPercent100thsCommandParams + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.put("readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercent100thsAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercent100thsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercent100thsCommandParams + ); + readWindowCoveringInteractionInfo.put("readCurrentPositionLiftPercent100thsAttribute", readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercent100thsAttribute( + ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercent100thsAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercent100thsCommandParams + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.put("readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); + Map readWindowCoveringAttributeListCommandParams = new LinkedHashMap(); + InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster).readAttributeListAttribute( + ( ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback + ) callback + ); + }, + () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterAttributeListAttributeCallback(), + readWindowCoveringAttributeListCommandParams + ); + readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.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); - readWindowCoveringInteractionInfo.put( - "readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("windowCovering", readWindowCoveringInteractionInfo); - return readAttributeMap; + readWindowCoveringFeatureMapCommandParams + ); + readWindowCoveringInteractionInfo.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 + ); + readWindowCoveringInteractionInfo.put("readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("windowCovering", readWindowCoveringInteractionInfo); + return readAttributeMap; } } + diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java index 4ee787dfd94515..a70c5b71a4a9de 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java @@ -29,2466 +29,2293 @@ public class ClusterWriteMapping { public Map> getWriteAttributeMap() { Map> writeAttributeMap = new HashMap<>(); - Map writeAccessControlInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("accessControl", writeAccessControlInteractionInfo); - Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); - Map writeAdministratorCommissioningInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "administratorCommissioning", writeAdministratorCommissioningInteractionInfo); - Map writeApplicationBasicInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("applicationBasic", writeApplicationBasicInteractionInfo); - Map writeApplicationLauncherInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("applicationLauncher", writeApplicationLauncherInteractionInfo); - Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); - Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); - Map writeBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBasicNodeLabelCommandParams = - new LinkedHashMap(); - CommandParameterInfo basicnodeLabelCommandParameterInfo = - new CommandParameterInfo("value", String.class); - writeBasicNodeLabelCommandParams.put("value", basicnodeLabelCommandParameterInfo); - InteractionInfo writeBasicNodeLabelAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .writeNodeLabelAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicNodeLabelCommandParams); - writeBasicInteractionInfo.put( - "writeNodeLabelAttribute", writeBasicNodeLabelAttributeInteractionInfo); - Map writeBasicLocationCommandParams = - new LinkedHashMap(); - CommandParameterInfo basiclocationCommandParameterInfo = - new CommandParameterInfo("value", String.class); - writeBasicLocationCommandParams.put("value", basiclocationCommandParameterInfo); - InteractionInfo writeBasicLocationAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .writeLocationAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicLocationCommandParams); - writeBasicInteractionInfo.put( - "writeLocationAttribute", writeBasicLocationAttributeInteractionInfo); - Map writeBasicLocalConfigDisabledCommandParams = - new LinkedHashMap(); - CommandParameterInfo basiclocalConfigDisabledCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeBasicLocalConfigDisabledCommandParams.put( - "value", basiclocalConfigDisabledCommandParameterInfo); - InteractionInfo writeBasicLocalConfigDisabledAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster) - .writeLocalConfigDisabledAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicLocalConfigDisabledCommandParams); - writeBasicInteractionInfo.put( - "writeLocalConfigDisabledAttribute", writeBasicLocalConfigDisabledAttributeInteractionInfo); - writeAttributeMap.put("basic", writeBasicInteractionInfo); - Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBinaryInputBasicOutOfServiceCommandParams = - new LinkedHashMap(); - CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); - Map writeBindingInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("binding", writeBindingInteractionInfo); - Map writeBooleanStateInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("booleanState", writeBooleanStateInteractionInfo); - Map writeBridgedActionsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("bridgedActions", writeBridgedActionsInteractionInfo); - Map writeBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("bridgedDeviceBasic", writeBridgedDeviceBasicInteractionInfo); - Map writeChannelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("channel", writeChannelInteractionInfo); - Map writeColorControlInteractionInfo = new LinkedHashMap<>(); - Map writeColorControlColorControlOptionsCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlcolorControlOptionsCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeColorControlColorControlOptionsCommandParams.put( - "value", colorControlcolorControlOptionsCommandParameterInfo); - InteractionInfo writeColorControlColorControlOptionsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .writeColorControlOptionsAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorControlOptionsCommandParams); - writeColorControlInteractionInfo.put( - "writeColorControlOptionsAttribute", - writeColorControlColorControlOptionsAttributeInteractionInfo); - Map writeColorControlWhitePointXCommandParams = - new LinkedHashMap(); - CommandParameterInfo colorControlwhitePointXCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlwhitePointYCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); - Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map writeContentLauncherSupportedStreamingProtocolsCommandParams = - new LinkedHashMap(); - CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); - Map writeDescriptorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("descriptor", writeDescriptorInteractionInfo); - Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); - Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); - Map writeDoorLockLanguageCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLocklanguageCommandParameterInfo = - new CommandParameterInfo("value", 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 writeDoorLockAutoRelockTimeCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = - new CommandParameterInfo("value", 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); - 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 writeDoorLockEnableOneTouchLockingCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = - new CommandParameterInfo("value", 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 writeDoorLockEnablePrivacyModeButtonCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = - new CommandParameterInfo("value", 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 writeDoorLockWrongCodeEntryLimitCommandParams = - new LinkedHashMap(); - CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); - Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); - Map writeEthernetNetworkDiagnosticsInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); - Map writeFixedLabelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("fixedLabel", writeFixedLabelInteractionInfo); - Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); - Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeGeneralCommissioningBreadcrumbCommandParams = - new LinkedHashMap(); - CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); - Map writeGeneralDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); - Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("groupKeyManagement", writeGroupKeyManagementInteractionInfo); - Map writeGroupsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("groups", writeGroupsInteractionInfo); - Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); - Map writeIdentifyIdentifyTimeCommandParams = - new LinkedHashMap(); - CommandParameterInfo identifyidentifyTimeCommandParameterInfo = - new CommandParameterInfo("value", 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 writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); - Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); - Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); - Map writeLevelControlOptionsCommandParams = - new LinkedHashMap(); - CommandParameterInfo levelControloptionsCommandParameterInfo = - new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo levelControlonLevelCommandParameterInfo = - new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); - Map writeLocalizationConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map writeLocalizationConfigurationActiveLocaleCommandParams = - new LinkedHashMap(); - CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = - new CommandParameterInfo("value", 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); - Map writeLowPowerInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("lowPower", writeLowPowerInteractionInfo); - Map writeMediaInputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("mediaInput", writeMediaInputInteractionInfo); - Map writeMediaPlaybackInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("mediaPlayback", writeMediaPlaybackInteractionInfo); - Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); - Map writeModeSelectOnModeCommandParams = - new LinkedHashMap(); - CommandParameterInfo modeSelectonModeCommandParameterInfo = - new CommandParameterInfo("value", 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 writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeNetworkCommissioningInterfaceEnabledCommandParams = - new LinkedHashMap(); - CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); - Map writeOtaSoftwareUpdateProviderInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); - Map writeOtaSoftwareUpdateRequestorInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); - Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); - Map writeOnOffInteractionInfo = new LinkedHashMap<>(); - Map writeOnOffOnTimeCommandParams = - new LinkedHashMap(); - CommandParameterInfo onOffonTimeCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = - new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); - Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); - Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); - Map writePowerSourceConfigurationInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); - Map writePressureMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); - Map writePumpConfigurationAndControlInteractionInfo = - new LinkedHashMap<>(); - Map - writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = - new LinkedHashMap(); - CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = - new CommandParameterInfo("value", 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); - Map writeRelativeHumidityMeasurementInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put( - "relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); - Map writeScenesInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("scenes", writeScenesInteractionInfo); - Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); - Map writeSwitchInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("switch", writeSwitchInteractionInfo); - Map writeTargetNavigatorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("targetNavigator", writeTargetNavigatorInteractionInfo); - Map writeTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("temperatureMeasurement", writeTemperatureMeasurementInteractionInfo); - Map writeTestClusterInteractionInfo = new LinkedHashMap<>(); - Map writeTestClusterBooleanCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterbooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterBooleanCommandParams.put("value", testClusterbooleanCommandParameterInfo); - InteractionInfo writeTestClusterBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBooleanCommandParams); - writeTestClusterInteractionInfo.put( - "writeBooleanAttribute", writeTestClusterBooleanAttributeInteractionInfo); - Map writeTestClusterBitmap8CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterbitmap8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterBitmap8CommandParams.put("value", testClusterbitmap8CommandParameterInfo); - InteractionInfo writeTestClusterBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeBitmap8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap8CommandParams); - writeTestClusterInteractionInfo.put( - "writeBitmap8Attribute", writeTestClusterBitmap8AttributeInteractionInfo); - Map writeTestClusterBitmap16CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterbitmap16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterBitmap16CommandParams.put("value", testClusterbitmap16CommandParameterInfo); - InteractionInfo writeTestClusterBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeBitmap16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap16CommandParams); - writeTestClusterInteractionInfo.put( - "writeBitmap16Attribute", writeTestClusterBitmap16AttributeInteractionInfo); - Map writeTestClusterBitmap32CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterbitmap32CommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterBitmap32CommandParams.put("value", testClusterbitmap32CommandParameterInfo); - InteractionInfo writeTestClusterBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeBitmap32Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap32CommandParams); - writeTestClusterInteractionInfo.put( - "writeBitmap32Attribute", writeTestClusterBitmap32AttributeInteractionInfo); - Map writeTestClusterBitmap64CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterbitmap64CommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterBitmap64CommandParams.put("value", testClusterbitmap64CommandParameterInfo); - InteractionInfo writeTestClusterBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeBitmap64Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap64CommandParams); - writeTestClusterInteractionInfo.put( - "writeBitmap64Attribute", writeTestClusterBitmap64AttributeInteractionInfo); - Map writeTestClusterInt8uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterInt8uCommandParams.put("value", testClusterint8uCommandParameterInfo); - InteractionInfo writeTestClusterInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt8uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt8uAttribute", writeTestClusterInt8uAttributeInteractionInfo); - Map writeTestClusterInt16uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterInt16uCommandParams.put("value", testClusterint16uCommandParameterInfo); - InteractionInfo writeTestClusterInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt16uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt16uAttribute", writeTestClusterInt16uAttributeInteractionInfo); - Map writeTestClusterInt24uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint24uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt24uCommandParams.put("value", testClusterint24uCommandParameterInfo); - InteractionInfo writeTestClusterInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt24uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt24uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt24uAttribute", writeTestClusterInt24uAttributeInteractionInfo); - Map writeTestClusterInt32uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint32uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt32uCommandParams.put("value", testClusterint32uCommandParameterInfo); - InteractionInfo writeTestClusterInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt32uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt32uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt32uAttribute", writeTestClusterInt32uAttributeInteractionInfo); - Map writeTestClusterInt40uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint40uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt40uCommandParams.put("value", testClusterint40uCommandParameterInfo); - InteractionInfo writeTestClusterInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt40uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt40uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt40uAttribute", writeTestClusterInt40uAttributeInteractionInfo); - Map writeTestClusterInt48uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint48uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt48uCommandParams.put("value", testClusterint48uCommandParameterInfo); - InteractionInfo writeTestClusterInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt48uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt48uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt48uAttribute", writeTestClusterInt48uAttributeInteractionInfo); - Map writeTestClusterInt56uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint56uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt56uCommandParams.put("value", testClusterint56uCommandParameterInfo); - InteractionInfo writeTestClusterInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt56uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt56uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt56uAttribute", writeTestClusterInt56uAttributeInteractionInfo); - Map writeTestClusterInt64uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint64uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt64uCommandParams.put("value", testClusterint64uCommandParameterInfo); - InteractionInfo writeTestClusterInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt64uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt64uCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt64uAttribute", writeTestClusterInt64uAttributeInteractionInfo); - Map writeTestClusterInt8sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterInt8sCommandParams.put("value", testClusterint8sCommandParameterInfo); - InteractionInfo writeTestClusterInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt8sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt8sAttribute", writeTestClusterInt8sAttributeInteractionInfo); - Map writeTestClusterInt16sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterInt16sCommandParams.put("value", testClusterint16sCommandParameterInfo); - InteractionInfo writeTestClusterInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt16sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt16sAttribute", writeTestClusterInt16sAttributeInteractionInfo); - Map writeTestClusterInt24sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint24sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt24sCommandParams.put("value", testClusterint24sCommandParameterInfo); - InteractionInfo writeTestClusterInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt24sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt24sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt24sAttribute", writeTestClusterInt24sAttributeInteractionInfo); - Map writeTestClusterInt32sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint32sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt32sCommandParams.put("value", testClusterint32sCommandParameterInfo); - InteractionInfo writeTestClusterInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt32sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt32sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt32sAttribute", writeTestClusterInt32sAttributeInteractionInfo); - Map writeTestClusterInt40sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint40sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt40sCommandParams.put("value", testClusterint40sCommandParameterInfo); - InteractionInfo writeTestClusterInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt40sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt40sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt40sAttribute", writeTestClusterInt40sAttributeInteractionInfo); - Map writeTestClusterInt48sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint48sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt48sCommandParams.put("value", testClusterint48sCommandParameterInfo); - InteractionInfo writeTestClusterInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt48sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt48sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt48sAttribute", writeTestClusterInt48sAttributeInteractionInfo); - Map writeTestClusterInt56sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint56sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt56sCommandParams.put("value", testClusterint56sCommandParameterInfo); - InteractionInfo writeTestClusterInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt56sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt56sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt56sAttribute", writeTestClusterInt56sAttributeInteractionInfo); - Map writeTestClusterInt64sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterint64sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterInt64sCommandParams.put("value", testClusterint64sCommandParameterInfo); - InteractionInfo writeTestClusterInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeInt64sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt64sCommandParams); - writeTestClusterInteractionInfo.put( - "writeInt64sAttribute", writeTestClusterInt64sAttributeInteractionInfo); - Map writeTestClusterEnum8CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterenum8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterEnum8CommandParams.put("value", testClusterenum8CommandParameterInfo); - InteractionInfo writeTestClusterEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeEnum8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnum8CommandParams); - writeTestClusterInteractionInfo.put( - "writeEnum8Attribute", writeTestClusterEnum8AttributeInteractionInfo); - Map writeTestClusterEnum16CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterenum16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterEnum16CommandParams.put("value", testClusterenum16CommandParameterInfo); - InteractionInfo writeTestClusterEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeEnum16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnum16CommandParams); - writeTestClusterInteractionInfo.put( - "writeEnum16Attribute", writeTestClusterEnum16AttributeInteractionInfo); - Map writeTestClusterFloatSingleCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterfloatSingleCommandParameterInfo = - new CommandParameterInfo("value", Float.class); - writeTestClusterFloatSingleCommandParams.put( - "value", testClusterfloatSingleCommandParameterInfo); - InteractionInfo writeTestClusterFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeFloatSingleAttribute( - (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterFloatSingleCommandParams); - writeTestClusterInteractionInfo.put( - "writeFloatSingleAttribute", writeTestClusterFloatSingleAttributeInteractionInfo); - Map writeTestClusterFloatDoubleCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterfloatDoubleCommandParameterInfo = - new CommandParameterInfo("value", Double.class); - writeTestClusterFloatDoubleCommandParams.put( - "value", testClusterfloatDoubleCommandParameterInfo); - InteractionInfo writeTestClusterFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeFloatDoubleAttribute( - (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterFloatDoubleCommandParams); - writeTestClusterInteractionInfo.put( - "writeFloatDoubleAttribute", writeTestClusterFloatDoubleAttributeInteractionInfo); - Map writeTestClusterOctetStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusteroctetStringCommandParameterInfo = - new CommandParameterInfo("value", byte[].class); - writeTestClusterOctetStringCommandParams.put( - "value", testClusteroctetStringCommandParameterInfo); - InteractionInfo writeTestClusterOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeOctetStringAttribute( - (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterOctetStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeOctetStringAttribute", writeTestClusterOctetStringAttributeInteractionInfo); - Map writeTestClusterLongOctetStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterlongOctetStringCommandParameterInfo = - new CommandParameterInfo("value", byte[].class); - writeTestClusterLongOctetStringCommandParams.put( - "value", testClusterlongOctetStringCommandParameterInfo); - InteractionInfo writeTestClusterLongOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeLongOctetStringAttribute( - (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterLongOctetStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeLongOctetStringAttribute", writeTestClusterLongOctetStringAttributeInteractionInfo); - Map writeTestClusterCharStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustercharStringCommandParameterInfo = - new CommandParameterInfo("value", String.class); - writeTestClusterCharStringCommandParams.put("value", testClustercharStringCommandParameterInfo); - InteractionInfo writeTestClusterCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeCharStringAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterCharStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeCharStringAttribute", writeTestClusterCharStringAttributeInteractionInfo); - Map writeTestClusterLongCharStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterlongCharStringCommandParameterInfo = - new CommandParameterInfo("value", String.class); - writeTestClusterLongCharStringCommandParams.put( - "value", testClusterlongCharStringCommandParameterInfo); - InteractionInfo writeTestClusterLongCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeLongCharStringAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterLongCharStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeLongCharStringAttribute", writeTestClusterLongCharStringAttributeInteractionInfo); - Map writeTestClusterEpochUsCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterepochUsCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterEpochUsCommandParams.put("value", testClusterepochUsCommandParameterInfo); - InteractionInfo writeTestClusterEpochUsAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeEpochUsAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEpochUsCommandParams); - writeTestClusterInteractionInfo.put( - "writeEpochUsAttribute", writeTestClusterEpochUsAttributeInteractionInfo); - Map writeTestClusterEpochSCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterepochSCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterEpochSCommandParams.put("value", testClusterepochSCommandParameterInfo); - InteractionInfo writeTestClusterEpochSAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeEpochSAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEpochSCommandParams); - writeTestClusterInteractionInfo.put( - "writeEpochSAttribute", writeTestClusterEpochSAttributeInteractionInfo); - Map writeTestClusterVendorIdCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustervendorIdCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterVendorIdCommandParams.put("value", testClustervendorIdCommandParameterInfo); - InteractionInfo writeTestClusterVendorIdAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeVendorIdAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterVendorIdCommandParams); - writeTestClusterInteractionInfo.put( - "writeVendorIdAttribute", writeTestClusterVendorIdAttributeInteractionInfo); - Map writeTestClusterEnumAttrCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterenumAttrCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterEnumAttrCommandParams.put("value", testClusterenumAttrCommandParameterInfo); - InteractionInfo writeTestClusterEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeEnumAttrAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnumAttrCommandParams); - writeTestClusterInteractionInfo.put( - "writeEnumAttrAttribute", writeTestClusterEnumAttrAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt8uCommandParams.put( - "value", testClusterrangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt8uCommandParams); - writeTestClusterInteractionInfo.put( - "writeRangeRestrictedInt8uAttribute", - writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt8sCommandParams.put( - "value", testClusterrangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt8sCommandParams); - writeTestClusterInteractionInfo.put( - "writeRangeRestrictedInt8sAttribute", - writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt16uCommandParams.put( - "value", testClusterrangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt16uCommandParams); - writeTestClusterInteractionInfo.put( - "writeRangeRestrictedInt16uAttribute", - writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt16sCommandParams.put( - "value", testClusterrangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt16sCommandParams); - writeTestClusterInteractionInfo.put( - "writeRangeRestrictedInt16sAttribute", - writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo); - Map writeTestClusterTimedWriteBooleanCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustertimedWriteBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterTimedWriteBooleanCommandParams.put( - "value", testClustertimedWriteBooleanCommandParameterInfo); - InteractionInfo writeTestClusterTimedWriteBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeTimedWriteBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) commandArguments.get("value"), - 10000); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterTimedWriteBooleanCommandParams); - writeTestClusterInteractionInfo.put( - "writeTimedWriteBooleanAttribute", - writeTestClusterTimedWriteBooleanAttributeInteractionInfo); - Map writeTestClusterGeneralErrorBooleanCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClustergeneralErrorBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterGeneralErrorBooleanCommandParams.put( - "value", testClustergeneralErrorBooleanCommandParameterInfo); - InteractionInfo writeTestClusterGeneralErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeGeneralErrorBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterGeneralErrorBooleanCommandParams); - writeTestClusterInteractionInfo.put( - "writeGeneralErrorBooleanAttribute", - writeTestClusterGeneralErrorBooleanAttributeInteractionInfo); - Map writeTestClusterClusterErrorBooleanCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterclusterErrorBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterClusterErrorBooleanCommandParams.put( - "value", testClusterclusterErrorBooleanCommandParameterInfo); - InteractionInfo writeTestClusterClusterErrorBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeClusterErrorBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterClusterErrorBooleanCommandParams); - writeTestClusterInteractionInfo.put( - "writeClusterErrorBooleanAttribute", - writeTestClusterClusterErrorBooleanAttributeInteractionInfo); - Map writeTestClusterUnsupportedCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusterunsupportedCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterUnsupportedCommandParams.put( - "value", testClusterunsupportedCommandParameterInfo); - InteractionInfo writeTestClusterUnsupportedAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeUnsupportedAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterUnsupportedCommandParams); - writeTestClusterInteractionInfo.put( - "writeUnsupportedAttribute", writeTestClusterUnsupportedAttributeInteractionInfo); - Map writeTestClusterNullableBooleanCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableBooleanCommandParameterInfo = - new CommandParameterInfo("value", Boolean.class); - writeTestClusterNullableBooleanCommandParams.put( - "value", testClusternullableBooleanCommandParameterInfo); - InteractionInfo writeTestClusterNullableBooleanAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableBooleanAttribute( - (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBooleanCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableBooleanAttribute", writeTestClusterNullableBooleanAttributeInteractionInfo); - Map writeTestClusterNullableBitmap8CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableBitmap8CommandParams.put( - "value", testClusternullableBitmap8CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableBitmap8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap8CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableBitmap8Attribute", writeTestClusterNullableBitmap8AttributeInteractionInfo); - Map writeTestClusterNullableBitmap16CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableBitmap16CommandParams.put( - "value", testClusternullableBitmap16CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableBitmap16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap16CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableBitmap16Attribute", writeTestClusterNullableBitmap16AttributeInteractionInfo); - Map writeTestClusterNullableBitmap32CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap32CommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableBitmap32CommandParams.put( - "value", testClusternullableBitmap32CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap32AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableBitmap32Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap32CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableBitmap32Attribute", writeTestClusterNullableBitmap32AttributeInteractionInfo); - Map writeTestClusterNullableBitmap64CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap64CommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableBitmap64CommandParams.put( - "value", testClusternullableBitmap64CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap64AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableBitmap64Attribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap64CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableBitmap64Attribute", writeTestClusterNullableBitmap64AttributeInteractionInfo); - Map writeTestClusterNullableInt8uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt8uCommandParams.put( - "value", testClusternullableInt8uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt8uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt8uAttribute", writeTestClusterNullableInt8uAttributeInteractionInfo); - Map writeTestClusterNullableInt16uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt16uCommandParams.put( - "value", testClusternullableInt16uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt16uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt16uAttribute", writeTestClusterNullableInt16uAttributeInteractionInfo); - Map writeTestClusterNullableInt24uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt24uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt24uCommandParams.put( - "value", testClusternullableInt24uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt24uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt24uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt24uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt24uAttribute", writeTestClusterNullableInt24uAttributeInteractionInfo); - Map writeTestClusterNullableInt32uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt32uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt32uCommandParams.put( - "value", testClusternullableInt32uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt32uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt32uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt32uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt32uAttribute", writeTestClusterNullableInt32uAttributeInteractionInfo); - Map writeTestClusterNullableInt40uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt40uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt40uCommandParams.put( - "value", testClusternullableInt40uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt40uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt40uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt40uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt40uAttribute", writeTestClusterNullableInt40uAttributeInteractionInfo); - Map writeTestClusterNullableInt48uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt48uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt48uCommandParams.put( - "value", testClusternullableInt48uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt48uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt48uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt48uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt48uAttribute", writeTestClusterNullableInt48uAttributeInteractionInfo); - Map writeTestClusterNullableInt56uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt56uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt56uCommandParams.put( - "value", testClusternullableInt56uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt56uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt56uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt56uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt56uAttribute", writeTestClusterNullableInt56uAttributeInteractionInfo); - Map writeTestClusterNullableInt64uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt64uCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt64uCommandParams.put( - "value", testClusternullableInt64uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt64uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt64uAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt64uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt64uAttribute", writeTestClusterNullableInt64uAttributeInteractionInfo); - Map writeTestClusterNullableInt8sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt8sCommandParams.put( - "value", testClusternullableInt8sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt8sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt8sAttribute", writeTestClusterNullableInt8sAttributeInteractionInfo); - Map writeTestClusterNullableInt16sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt16sCommandParams.put( - "value", testClusternullableInt16sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt16sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt16sAttribute", writeTestClusterNullableInt16sAttributeInteractionInfo); - Map writeTestClusterNullableInt24sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt24sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt24sCommandParams.put( - "value", testClusternullableInt24sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt24sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt24sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt24sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt24sAttribute", writeTestClusterNullableInt24sAttributeInteractionInfo); - Map writeTestClusterNullableInt32sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt32sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt32sCommandParams.put( - "value", testClusternullableInt32sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt32sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt32sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt32sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt32sAttribute", writeTestClusterNullableInt32sAttributeInteractionInfo); - Map writeTestClusterNullableInt40sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt40sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt40sCommandParams.put( - "value", testClusternullableInt40sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt40sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt40sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt40sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt40sAttribute", writeTestClusterNullableInt40sAttributeInteractionInfo); - Map writeTestClusterNullableInt48sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt48sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt48sCommandParams.put( - "value", testClusternullableInt48sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt48sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt48sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt48sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt48sAttribute", writeTestClusterNullableInt48sAttributeInteractionInfo); - Map writeTestClusterNullableInt56sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt56sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt56sCommandParams.put( - "value", testClusternullableInt56sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt56sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt56sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt56sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt56sAttribute", writeTestClusterNullableInt56sAttributeInteractionInfo); - Map writeTestClusterNullableInt64sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableInt64sCommandParameterInfo = - new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt64sCommandParams.put( - "value", testClusternullableInt64sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt64sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableInt64sAttribute( - (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt64sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableInt64sAttribute", writeTestClusterNullableInt64sAttributeInteractionInfo); - Map writeTestClusterNullableEnum8CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableEnum8CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnum8CommandParams.put( - "value", testClusternullableEnum8CommandParameterInfo); - InteractionInfo writeTestClusterNullableEnum8AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableEnum8Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnum8CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableEnum8Attribute", writeTestClusterNullableEnum8AttributeInteractionInfo); - Map writeTestClusterNullableEnum16CommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableEnum16CommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnum16CommandParams.put( - "value", testClusternullableEnum16CommandParameterInfo); - InteractionInfo writeTestClusterNullableEnum16AttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableEnum16Attribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnum16CommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableEnum16Attribute", writeTestClusterNullableEnum16AttributeInteractionInfo); - Map writeTestClusterNullableFloatSingleCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableFloatSingleCommandParameterInfo = - new CommandParameterInfo("value", Float.class); - writeTestClusterNullableFloatSingleCommandParams.put( - "value", testClusternullableFloatSingleCommandParameterInfo); - InteractionInfo writeTestClusterNullableFloatSingleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableFloatSingleAttribute( - (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableFloatSingleCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableFloatSingleAttribute", - writeTestClusterNullableFloatSingleAttributeInteractionInfo); - Map writeTestClusterNullableFloatDoubleCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableFloatDoubleCommandParameterInfo = - new CommandParameterInfo("value", Double.class); - writeTestClusterNullableFloatDoubleCommandParams.put( - "value", testClusternullableFloatDoubleCommandParameterInfo); - InteractionInfo writeTestClusterNullableFloatDoubleAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableFloatDoubleAttribute( - (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableFloatDoubleCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableFloatDoubleAttribute", - writeTestClusterNullableFloatDoubleAttributeInteractionInfo); - Map writeTestClusterNullableOctetStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableOctetStringCommandParameterInfo = - new CommandParameterInfo("value", byte[].class); - writeTestClusterNullableOctetStringCommandParams.put( - "value", testClusternullableOctetStringCommandParameterInfo); - InteractionInfo writeTestClusterNullableOctetStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableOctetStringAttribute( - (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableOctetStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableOctetStringAttribute", - writeTestClusterNullableOctetStringAttributeInteractionInfo); - Map writeTestClusterNullableCharStringCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableCharStringCommandParameterInfo = - new CommandParameterInfo("value", String.class); - writeTestClusterNullableCharStringCommandParams.put( - "value", testClusternullableCharStringCommandParameterInfo); - InteractionInfo writeTestClusterNullableCharStringAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableCharStringAttribute( - (DefaultClusterCallback) callback, (String) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableCharStringCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableCharStringAttribute", - writeTestClusterNullableCharStringAttributeInteractionInfo); - Map writeTestClusterNullableEnumAttrCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableEnumAttrCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnumAttrCommandParams.put( - "value", testClusternullableEnumAttrCommandParameterInfo); - InteractionInfo writeTestClusterNullableEnumAttrAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableEnumAttrAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnumAttrCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableEnumAttrAttribute", writeTestClusterNullableEnumAttrAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt8uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt8uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt8uCommandParams.put( - "value", testClusternullableRangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt8uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableRangeRestrictedInt8uAttribute", - writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt8sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt8sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt8sCommandParams.put( - "value", testClusternullableRangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt8sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableRangeRestrictedInt8sAttribute", - writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt16uCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt16uCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt16uCommandParams.put( - "value", testClusternullableRangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt16uCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableRangeRestrictedInt16uAttribute", - writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt16sCommandParams = - new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt16sCommandParameterInfo = - new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt16sCommandParams.put( - "value", testClusternullableRangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = - new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .writeNullableRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt16sCommandParams); - writeTestClusterInteractionInfo.put( - "writeNullableRangeRestrictedInt16sAttribute", - writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); - writeAttributeMap.put("testCluster", writeTestClusterInteractionInfo); - Map writeThermostatInteractionInfo = new LinkedHashMap<>(); - Map writeThermostatOccupiedCoolingSetpointCommandParams = - new LinkedHashMap(); - CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = - new CommandParameterInfo("value", 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 writeThermostatMinHeatSetpointLimitCommandParams = - new LinkedHashMap(); - CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = - new CommandParameterInfo("value", 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 writeThermostatControlSequenceOfOperationCommandParams = - new LinkedHashMap(); - CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatsystemModeCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); - Map writeThermostatUserInterfaceConfigurationInteractionInfo = - new LinkedHashMap<>(); - Map - writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = - new LinkedHashMap(); - CommandParameterInfo - thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = - new CommandParameterInfo("value", 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); - 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); - Map writeThreadNetworkDiagnosticsInteractionInfo = - new LinkedHashMap<>(); - writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); - Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeTimeFormatLocalizationHourFormatCommandParams = - new LinkedHashMap(); - CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = - new CommandParameterInfo("value", 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(); - CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); - Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeUnitLocalizationTemperatureUnitCommandParams = - new LinkedHashMap(); - CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = - new CommandParameterInfo("value", 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); - writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); - Map writeUserLabelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("userLabel", writeUserLabelInteractionInfo); - Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); - Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); - Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map writeWindowCoveringModeCommandParams = - new LinkedHashMap(); - CommandParameterInfo windowCoveringmodeCommandParameterInfo = - new CommandParameterInfo("value", 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 writeAccessControlInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("accessControl", writeAccessControlInteractionInfo); + Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); + Map writeAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("administratorCommissioning", writeAdministratorCommissioningInteractionInfo); + Map writeApplicationBasicInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("applicationBasic", writeApplicationBasicInteractionInfo); + Map writeApplicationLauncherInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("applicationLauncher", writeApplicationLauncherInteractionInfo); + Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); + Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); + Map writeBasicInteractionInfo = new LinkedHashMap<>(); + Map writeBasicNodeLabelCommandParams = new LinkedHashMap(); + CommandParameterInfo basicnodeLabelCommandParameterInfo = new CommandParameterInfo("value", String.class); + writeBasicNodeLabelCommandParams.put("value",basicnodeLabelCommandParameterInfo); + InteractionInfo writeBasicNodeLabelAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).writeNodeLabelAttribute( + (DefaultClusterCallback) callback, + (String) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicNodeLabelCommandParams + ); + writeBasicInteractionInfo.put("writeNodeLabelAttribute", writeBasicNodeLabelAttributeInteractionInfo); + Map writeBasicLocationCommandParams = new LinkedHashMap(); + CommandParameterInfo basiclocationCommandParameterInfo = new CommandParameterInfo("value", String.class); + writeBasicLocationCommandParams.put("value",basiclocationCommandParameterInfo); + InteractionInfo writeBasicLocationAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).writeLocationAttribute( + (DefaultClusterCallback) callback, + (String) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicLocationCommandParams + ); + writeBasicInteractionInfo.put("writeLocationAttribute", writeBasicLocationAttributeInteractionInfo); + Map writeBasicLocalConfigDisabledCommandParams = new LinkedHashMap(); + CommandParameterInfo basiclocalConfigDisabledCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeBasicLocalConfigDisabledCommandParams.put("value",basiclocalConfigDisabledCommandParameterInfo); + InteractionInfo writeBasicLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster).writeLocalConfigDisabledAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicLocalConfigDisabledCommandParams + ); + writeBasicInteractionInfo.put("writeLocalConfigDisabledAttribute", writeBasicLocalConfigDisabledAttributeInteractionInfo); + writeAttributeMap.put("basic", writeBasicInteractionInfo); + Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); + Map writeBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); + CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); + Map writeBindingInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("binding", writeBindingInteractionInfo); + Map writeBooleanStateInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("booleanState", writeBooleanStateInteractionInfo); + Map writeBridgedActionsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bridgedActions", writeBridgedActionsInteractionInfo); + Map writeBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bridgedDeviceBasic", writeBridgedDeviceBasicInteractionInfo); + Map writeChannelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("channel", writeChannelInteractionInfo); + Map writeColorControlInteractionInfo = new LinkedHashMap<>(); + Map writeColorControlColorControlOptionsCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlcolorControlOptionsCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeColorControlColorControlOptionsCommandParams.put("value",colorControlcolorControlOptionsCommandParameterInfo); + InteractionInfo writeColorControlColorControlOptionsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster).writeColorControlOptionsAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorControlOptionsCommandParams + ); + writeColorControlInteractionInfo.put("writeColorControlOptionsAttribute", writeColorControlColorControlOptionsAttributeInteractionInfo); + Map writeColorControlWhitePointXCommandParams = new LinkedHashMap(); + CommandParameterInfo colorControlwhitePointXCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlwhitePointYCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); + Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); + Map writeContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); + CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); + Map writeDescriptorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("descriptor", writeDescriptorInteractionInfo); + Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); + Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); + Map writeDoorLockLanguageCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLocklanguageCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = new CommandParameterInfo("value", 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); + 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 writeDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); + CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); + Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); + Map writeEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); + Map writeFixedLabelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("fixedLabel", writeFixedLabelInteractionInfo); + Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); + Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); + Map writeGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); + CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); + Map writeGeneralDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); + Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("groupKeyManagement", writeGroupKeyManagementInteractionInfo); + Map writeGroupsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("groups", writeGroupsInteractionInfo); + Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); + Map writeIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); + CommandParameterInfo identifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("value", 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 writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); + Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); + Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); + Map writeLevelControlOptionsCommandParams = new LinkedHashMap(); + CommandParameterInfo levelControloptionsCommandParameterInfo = new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo levelControlonLevelCommandParameterInfo = new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); + Map writeLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); + Map writeLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); + CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = new CommandParameterInfo("value", 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); + Map writeLowPowerInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("lowPower", writeLowPowerInteractionInfo); + Map writeMediaInputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("mediaInput", writeMediaInputInteractionInfo); + Map writeMediaPlaybackInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("mediaPlayback", writeMediaPlaybackInteractionInfo); + Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); + Map writeModeSelectOnModeCommandParams = new LinkedHashMap(); + CommandParameterInfo modeSelectonModeCommandParameterInfo = new CommandParameterInfo("value", 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 writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); + Map writeNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); + CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); + Map writeOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); + Map writeOtaSoftwareUpdateRequestorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); + Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); + Map writeOnOffInteractionInfo = new LinkedHashMap<>(); + Map writeOnOffOnTimeCommandParams = new LinkedHashMap(); + CommandParameterInfo onOffonTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); + Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); + Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); + Map writePowerSourceConfigurationInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); + Map writePressureMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); + Map writePumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); + Map writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); + CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = new CommandParameterInfo("value", 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); + Map writeRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); + Map writeScenesInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("scenes", writeScenesInteractionInfo); + Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); + Map writeSwitchInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("switch", writeSwitchInteractionInfo); + Map writeTargetNavigatorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("targetNavigator", writeTargetNavigatorInteractionInfo); + Map writeTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("temperatureMeasurement", writeTemperatureMeasurementInteractionInfo); + Map writeTestClusterInteractionInfo = new LinkedHashMap<>(); + Map writeTestClusterBooleanCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterbooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterBooleanCommandParams.put("value",testClusterbooleanCommandParameterInfo); + InteractionInfo writeTestClusterBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBooleanCommandParams + ); + writeTestClusterInteractionInfo.put("writeBooleanAttribute", writeTestClusterBooleanAttributeInteractionInfo); + Map writeTestClusterBitmap8CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterbitmap8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterBitmap8CommandParams.put("value",testClusterbitmap8CommandParameterInfo); + InteractionInfo writeTestClusterBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeBitmap8Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap8CommandParams + ); + writeTestClusterInteractionInfo.put("writeBitmap8Attribute", writeTestClusterBitmap8AttributeInteractionInfo); + Map writeTestClusterBitmap16CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterbitmap16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterBitmap16CommandParams.put("value",testClusterbitmap16CommandParameterInfo); + InteractionInfo writeTestClusterBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeBitmap16Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap16CommandParams + ); + writeTestClusterInteractionInfo.put("writeBitmap16Attribute", writeTestClusterBitmap16AttributeInteractionInfo); + Map writeTestClusterBitmap32CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterbitmap32CommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterBitmap32CommandParams.put("value",testClusterbitmap32CommandParameterInfo); + InteractionInfo writeTestClusterBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeBitmap32Attribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap32CommandParams + ); + writeTestClusterInteractionInfo.put("writeBitmap32Attribute", writeTestClusterBitmap32AttributeInteractionInfo); + Map writeTestClusterBitmap64CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterbitmap64CommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterBitmap64CommandParams.put("value",testClusterbitmap64CommandParameterInfo); + InteractionInfo writeTestClusterBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeBitmap64Attribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap64CommandParams + ); + writeTestClusterInteractionInfo.put("writeBitmap64Attribute", writeTestClusterBitmap64AttributeInteractionInfo); + Map writeTestClusterInt8uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterInt8uCommandParams.put("value",testClusterint8uCommandParameterInfo); + InteractionInfo writeTestClusterInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt8uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt8uAttribute", writeTestClusterInt8uAttributeInteractionInfo); + Map writeTestClusterInt16uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterInt16uCommandParams.put("value",testClusterint16uCommandParameterInfo); + InteractionInfo writeTestClusterInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt16uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt16uAttribute", writeTestClusterInt16uAttributeInteractionInfo); + Map writeTestClusterInt24uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint24uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt24uCommandParams.put("value",testClusterint24uCommandParameterInfo); + InteractionInfo writeTestClusterInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt24uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt24uAttribute", writeTestClusterInt24uAttributeInteractionInfo); + Map writeTestClusterInt32uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint32uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt32uCommandParams.put("value",testClusterint32uCommandParameterInfo); + InteractionInfo writeTestClusterInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt32uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt32uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt32uAttribute", writeTestClusterInt32uAttributeInteractionInfo); + Map writeTestClusterInt40uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint40uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt40uCommandParams.put("value",testClusterint40uCommandParameterInfo); + InteractionInfo writeTestClusterInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt40uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt40uAttribute", writeTestClusterInt40uAttributeInteractionInfo); + Map writeTestClusterInt48uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint48uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt48uCommandParams.put("value",testClusterint48uCommandParameterInfo); + InteractionInfo writeTestClusterInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt48uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt48uAttribute", writeTestClusterInt48uAttributeInteractionInfo); + Map writeTestClusterInt56uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint56uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt56uCommandParams.put("value",testClusterint56uCommandParameterInfo); + InteractionInfo writeTestClusterInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt56uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt56uAttribute", writeTestClusterInt56uAttributeInteractionInfo); + Map writeTestClusterInt64uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint64uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt64uCommandParams.put("value",testClusterint64uCommandParameterInfo); + InteractionInfo writeTestClusterInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt64uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt64uCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt64uAttribute", writeTestClusterInt64uAttributeInteractionInfo); + Map writeTestClusterInt8sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterInt8sCommandParams.put("value",testClusterint8sCommandParameterInfo); + InteractionInfo writeTestClusterInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt8sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt8sAttribute", writeTestClusterInt8sAttributeInteractionInfo); + Map writeTestClusterInt16sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterInt16sCommandParams.put("value",testClusterint16sCommandParameterInfo); + InteractionInfo writeTestClusterInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt16sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt16sAttribute", writeTestClusterInt16sAttributeInteractionInfo); + Map writeTestClusterInt24sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint24sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt24sCommandParams.put("value",testClusterint24sCommandParameterInfo); + InteractionInfo writeTestClusterInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt24sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt24sAttribute", writeTestClusterInt24sAttributeInteractionInfo); + Map writeTestClusterInt32sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint32sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt32sCommandParams.put("value",testClusterint32sCommandParameterInfo); + InteractionInfo writeTestClusterInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt32sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt32sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt32sAttribute", writeTestClusterInt32sAttributeInteractionInfo); + Map writeTestClusterInt40sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint40sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt40sCommandParams.put("value",testClusterint40sCommandParameterInfo); + InteractionInfo writeTestClusterInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt40sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt40sAttribute", writeTestClusterInt40sAttributeInteractionInfo); + Map writeTestClusterInt48sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint48sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt48sCommandParams.put("value",testClusterint48sCommandParameterInfo); + InteractionInfo writeTestClusterInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt48sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt48sAttribute", writeTestClusterInt48sAttributeInteractionInfo); + Map writeTestClusterInt56sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint56sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt56sCommandParams.put("value",testClusterint56sCommandParameterInfo); + InteractionInfo writeTestClusterInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt56sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt56sAttribute", writeTestClusterInt56sAttributeInteractionInfo); + Map writeTestClusterInt64sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterint64sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterInt64sCommandParams.put("value",testClusterint64sCommandParameterInfo); + InteractionInfo writeTestClusterInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeInt64sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt64sCommandParams + ); + writeTestClusterInteractionInfo.put("writeInt64sAttribute", writeTestClusterInt64sAttributeInteractionInfo); + Map writeTestClusterEnum8CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterenum8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterEnum8CommandParams.put("value",testClusterenum8CommandParameterInfo); + InteractionInfo writeTestClusterEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeEnum8Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnum8CommandParams + ); + writeTestClusterInteractionInfo.put("writeEnum8Attribute", writeTestClusterEnum8AttributeInteractionInfo); + Map writeTestClusterEnum16CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterenum16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterEnum16CommandParams.put("value",testClusterenum16CommandParameterInfo); + InteractionInfo writeTestClusterEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeEnum16Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnum16CommandParams + ); + writeTestClusterInteractionInfo.put("writeEnum16Attribute", writeTestClusterEnum16AttributeInteractionInfo); + Map writeTestClusterFloatSingleCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterfloatSingleCommandParameterInfo = new CommandParameterInfo("value", Float.class); + writeTestClusterFloatSingleCommandParams.put("value",testClusterfloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeFloatSingleAttribute( + (DefaultClusterCallback) callback, + (Float) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatSingleCommandParams + ); + writeTestClusterInteractionInfo.put("writeFloatSingleAttribute", writeTestClusterFloatSingleAttributeInteractionInfo); + Map writeTestClusterFloatDoubleCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterfloatDoubleCommandParameterInfo = new CommandParameterInfo("value", Double.class); + writeTestClusterFloatDoubleCommandParams.put("value",testClusterfloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeFloatDoubleAttribute( + (DefaultClusterCallback) callback, + (Double) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatDoubleCommandParams + ); + writeTestClusterInteractionInfo.put("writeFloatDoubleAttribute", writeTestClusterFloatDoubleAttributeInteractionInfo); + Map writeTestClusterOctetStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusteroctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); + writeTestClusterOctetStringCommandParams.put("value",testClusteroctetStringCommandParameterInfo); + InteractionInfo writeTestClusterOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeOctetStringAttribute( + (DefaultClusterCallback) callback, + (byte[]) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterOctetStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeOctetStringAttribute", writeTestClusterOctetStringAttributeInteractionInfo); + Map writeTestClusterLongOctetStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterlongOctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); + writeTestClusterLongOctetStringCommandParams.put("value",testClusterlongOctetStringCommandParameterInfo); + InteractionInfo writeTestClusterLongOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeLongOctetStringAttribute( + (DefaultClusterCallback) callback, + (byte[]) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterLongOctetStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeLongOctetStringAttribute", writeTestClusterLongOctetStringAttributeInteractionInfo); + Map writeTestClusterCharStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustercharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); + writeTestClusterCharStringCommandParams.put("value",testClustercharStringCommandParameterInfo); + InteractionInfo writeTestClusterCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeCharStringAttribute( + (DefaultClusterCallback) callback, + (String) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterCharStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeCharStringAttribute", writeTestClusterCharStringAttributeInteractionInfo); + Map writeTestClusterLongCharStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterlongCharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); + writeTestClusterLongCharStringCommandParams.put("value",testClusterlongCharStringCommandParameterInfo); + InteractionInfo writeTestClusterLongCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeLongCharStringAttribute( + (DefaultClusterCallback) callback, + (String) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterLongCharStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeLongCharStringAttribute", writeTestClusterLongCharStringAttributeInteractionInfo); + Map writeTestClusterEpochUsCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterepochUsCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterEpochUsCommandParams.put("value",testClusterepochUsCommandParameterInfo); + InteractionInfo writeTestClusterEpochUsAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeEpochUsAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEpochUsCommandParams + ); + writeTestClusterInteractionInfo.put("writeEpochUsAttribute", writeTestClusterEpochUsAttributeInteractionInfo); + Map writeTestClusterEpochSCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterepochSCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterEpochSCommandParams.put("value",testClusterepochSCommandParameterInfo); + InteractionInfo writeTestClusterEpochSAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeEpochSAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEpochSCommandParams + ); + writeTestClusterInteractionInfo.put("writeEpochSAttribute", writeTestClusterEpochSAttributeInteractionInfo); + Map writeTestClusterVendorIdCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustervendorIdCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterVendorIdCommandParams.put("value",testClustervendorIdCommandParameterInfo); + InteractionInfo writeTestClusterVendorIdAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeVendorIdAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterVendorIdCommandParams + ); + writeTestClusterInteractionInfo.put("writeVendorIdAttribute", writeTestClusterVendorIdAttributeInteractionInfo); + Map writeTestClusterEnumAttrCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterenumAttrCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterEnumAttrCommandParams.put("value",testClusterenumAttrCommandParameterInfo); + InteractionInfo writeTestClusterEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeEnumAttrAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnumAttrCommandParams + ); + writeTestClusterInteractionInfo.put("writeEnumAttrAttribute", writeTestClusterEnumAttrAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt8uCommandParams.put("value",testClusterrangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8uCommandParams + ); + writeTestClusterInteractionInfo.put("writeRangeRestrictedInt8uAttribute", writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt8sCommandParams.put("value",testClusterrangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8sCommandParams + ); + writeTestClusterInteractionInfo.put("writeRangeRestrictedInt8sAttribute", writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt16uCommandParams.put("value",testClusterrangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16uCommandParams + ); + writeTestClusterInteractionInfo.put("writeRangeRestrictedInt16uAttribute", writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt16sCommandParams.put("value",testClusterrangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16sCommandParams + ); + writeTestClusterInteractionInfo.put("writeRangeRestrictedInt16sAttribute", writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo); + Map writeTestClusterTimedWriteBooleanCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustertimedWriteBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterTimedWriteBooleanCommandParams.put("value",testClustertimedWriteBooleanCommandParameterInfo); + InteractionInfo writeTestClusterTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeTimedWriteBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + , 10000 + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterTimedWriteBooleanCommandParams + ); + writeTestClusterInteractionInfo.put("writeTimedWriteBooleanAttribute", writeTestClusterTimedWriteBooleanAttributeInteractionInfo); + Map writeTestClusterGeneralErrorBooleanCommandParams = new LinkedHashMap(); + CommandParameterInfo testClustergeneralErrorBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterGeneralErrorBooleanCommandParams.put("value",testClustergeneralErrorBooleanCommandParameterInfo); + InteractionInfo writeTestClusterGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeGeneralErrorBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterGeneralErrorBooleanCommandParams + ); + writeTestClusterInteractionInfo.put("writeGeneralErrorBooleanAttribute", writeTestClusterGeneralErrorBooleanAttributeInteractionInfo); + Map writeTestClusterClusterErrorBooleanCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterclusterErrorBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterClusterErrorBooleanCommandParams.put("value",testClusterclusterErrorBooleanCommandParameterInfo); + InteractionInfo writeTestClusterClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeClusterErrorBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterClusterErrorBooleanCommandParams + ); + writeTestClusterInteractionInfo.put("writeClusterErrorBooleanAttribute", writeTestClusterClusterErrorBooleanAttributeInteractionInfo); + Map writeTestClusterUnsupportedCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusterunsupportedCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterUnsupportedCommandParams.put("value",testClusterunsupportedCommandParameterInfo); + InteractionInfo writeTestClusterUnsupportedAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeUnsupportedAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterUnsupportedCommandParams + ); + writeTestClusterInteractionInfo.put("writeUnsupportedAttribute", writeTestClusterUnsupportedAttributeInteractionInfo); + Map writeTestClusterNullableBooleanCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); + writeTestClusterNullableBooleanCommandParams.put("value",testClusternullableBooleanCommandParameterInfo); + InteractionInfo writeTestClusterNullableBooleanAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBooleanCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableBooleanAttribute", writeTestClusterNullableBooleanAttributeInteractionInfo); + Map writeTestClusterNullableBitmap8CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableBitmap8CommandParams.put("value",testClusternullableBitmap8CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap8Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap8CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableBitmap8Attribute", writeTestClusterNullableBitmap8AttributeInteractionInfo); + Map writeTestClusterNullableBitmap16CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableBitmap16CommandParams.put("value",testClusternullableBitmap16CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap16Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap16CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableBitmap16Attribute", writeTestClusterNullableBitmap16AttributeInteractionInfo); + Map writeTestClusterNullableBitmap32CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap32CommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableBitmap32CommandParams.put("value",testClusternullableBitmap32CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap32AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap32Attribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap32CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableBitmap32Attribute", writeTestClusterNullableBitmap32AttributeInteractionInfo); + Map writeTestClusterNullableBitmap64CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap64CommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableBitmap64CommandParams.put("value",testClusternullableBitmap64CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap64AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap64Attribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap64CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableBitmap64Attribute", writeTestClusterNullableBitmap64AttributeInteractionInfo); + Map writeTestClusterNullableInt8uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt8uCommandParams.put("value",testClusternullableInt8uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt8uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt8uAttribute", writeTestClusterNullableInt8uAttributeInteractionInfo); + Map writeTestClusterNullableInt16uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt16uCommandParams.put("value",testClusternullableInt16uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt16uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt16uAttribute", writeTestClusterNullableInt16uAttributeInteractionInfo); + Map writeTestClusterNullableInt24uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt24uCommandParams.put("value",testClusternullableInt24uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt24uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt24uAttribute", writeTestClusterNullableInt24uAttributeInteractionInfo); + Map writeTestClusterNullableInt32uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt32uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt32uCommandParams.put("value",testClusternullableInt32uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt32uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt32uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt32uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt32uAttribute", writeTestClusterNullableInt32uAttributeInteractionInfo); + Map writeTestClusterNullableInt40uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt40uCommandParams.put("value",testClusternullableInt40uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt40uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt40uAttribute", writeTestClusterNullableInt40uAttributeInteractionInfo); + Map writeTestClusterNullableInt48uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt48uCommandParams.put("value",testClusternullableInt48uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt48uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt48uAttribute", writeTestClusterNullableInt48uAttributeInteractionInfo); + Map writeTestClusterNullableInt56uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt56uCommandParams.put("value",testClusternullableInt56uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt56uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt56uAttribute", writeTestClusterNullableInt56uAttributeInteractionInfo); + Map writeTestClusterNullableInt64uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt64uCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt64uCommandParams.put("value",testClusternullableInt64uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt64uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt64uAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt64uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt64uAttribute", writeTestClusterNullableInt64uAttributeInteractionInfo); + Map writeTestClusterNullableInt8sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt8sCommandParams.put("value",testClusternullableInt8sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt8sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt8sAttribute", writeTestClusterNullableInt8sAttributeInteractionInfo); + Map writeTestClusterNullableInt16sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt16sCommandParams.put("value",testClusternullableInt16sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt16sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt16sAttribute", writeTestClusterNullableInt16sAttributeInteractionInfo); + Map writeTestClusterNullableInt24sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt24sCommandParams.put("value",testClusternullableInt24sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt24sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt24sAttribute", writeTestClusterNullableInt24sAttributeInteractionInfo); + Map writeTestClusterNullableInt32sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt32sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt32sCommandParams.put("value",testClusternullableInt32sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt32sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt32sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt32sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt32sAttribute", writeTestClusterNullableInt32sAttributeInteractionInfo); + Map writeTestClusterNullableInt40sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt40sCommandParams.put("value",testClusternullableInt40sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt40sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt40sAttribute", writeTestClusterNullableInt40sAttributeInteractionInfo); + Map writeTestClusterNullableInt48sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt48sCommandParams.put("value",testClusternullableInt48sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt48sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt48sAttribute", writeTestClusterNullableInt48sAttributeInteractionInfo); + Map writeTestClusterNullableInt56sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt56sCommandParams.put("value",testClusternullableInt56sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt56sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt56sAttribute", writeTestClusterNullableInt56sAttributeInteractionInfo); + Map writeTestClusterNullableInt64sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableInt64sCommandParameterInfo = new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt64sCommandParams.put("value",testClusternullableInt64sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt64sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableInt64sAttribute( + (DefaultClusterCallback) callback, + (Long) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt64sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableInt64sAttribute", writeTestClusterNullableInt64sAttributeInteractionInfo); + Map writeTestClusterNullableEnum8CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableEnum8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnum8CommandParams.put("value",testClusternullableEnum8CommandParameterInfo); + InteractionInfo writeTestClusterNullableEnum8AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableEnum8Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnum8CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableEnum8Attribute", writeTestClusterNullableEnum8AttributeInteractionInfo); + Map writeTestClusterNullableEnum16CommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableEnum16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnum16CommandParams.put("value",testClusternullableEnum16CommandParameterInfo); + InteractionInfo writeTestClusterNullableEnum16AttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableEnum16Attribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnum16CommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableEnum16Attribute", writeTestClusterNullableEnum16AttributeInteractionInfo); + Map writeTestClusterNullableFloatSingleCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatSingleCommandParameterInfo = new CommandParameterInfo("value", Float.class); + writeTestClusterNullableFloatSingleCommandParams.put("value",testClusternullableFloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableFloatSingleAttribute( + (DefaultClusterCallback) callback, + (Float) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatSingleCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableFloatSingleAttribute", writeTestClusterNullableFloatSingleAttributeInteractionInfo); + Map writeTestClusterNullableFloatDoubleCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatDoubleCommandParameterInfo = new CommandParameterInfo("value", Double.class); + writeTestClusterNullableFloatDoubleCommandParams.put("value",testClusternullableFloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableFloatDoubleAttribute( + (DefaultClusterCallback) callback, + (Double) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatDoubleCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableFloatDoubleAttribute", writeTestClusterNullableFloatDoubleAttributeInteractionInfo); + Map writeTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableOctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); + writeTestClusterNullableOctetStringCommandParams.put("value",testClusternullableOctetStringCommandParameterInfo); + InteractionInfo writeTestClusterNullableOctetStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableOctetStringAttribute( + (DefaultClusterCallback) callback, + (byte[]) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableOctetStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableOctetStringAttribute", writeTestClusterNullableOctetStringAttributeInteractionInfo); + Map writeTestClusterNullableCharStringCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableCharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); + writeTestClusterNullableCharStringCommandParams.put("value",testClusternullableCharStringCommandParameterInfo); + InteractionInfo writeTestClusterNullableCharStringAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableCharStringAttribute( + (DefaultClusterCallback) callback, + (String) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableCharStringCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableCharStringAttribute", writeTestClusterNullableCharStringAttributeInteractionInfo); + Map writeTestClusterNullableEnumAttrCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableEnumAttrCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnumAttrCommandParams.put("value",testClusternullableEnumAttrCommandParameterInfo); + InteractionInfo writeTestClusterNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableEnumAttrAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnumAttrCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableEnumAttrAttribute", writeTestClusterNullableEnumAttrAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt8uCommandParams.put("value",testClusternullableRangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt8uAttribute", writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt8sCommandParams.put("value",testClusternullableRangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt8sAttribute", writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt16uCommandParams.put("value",testClusternullableRangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16uCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt16uAttribute", writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt16sCommandParams.put("value",testClusternullableRangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, + (Integer) + commandArguments.get("value") + + ); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16sCommandParams + ); + writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt16sAttribute", writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); + writeAttributeMap.put("testCluster", writeTestClusterInteractionInfo); + Map writeThermostatInteractionInfo = new LinkedHashMap<>(); + Map writeThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = new CommandParameterInfo("value", 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 writeThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = new CommandParameterInfo("value", 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 writeThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatsystemModeCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); + Map writeThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); + Map writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); + CommandParameterInfo thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = new CommandParameterInfo("value", 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); + 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); + Map writeThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); + Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); + Map writeTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); + CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = new CommandParameterInfo("value", 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(); + CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); + Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); + Map writeUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); + CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = new CommandParameterInfo("value", 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); + writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); + Map writeUserLabelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("userLabel", writeUserLabelInteractionInfo); + Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); + Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); + Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); + Map writeWindowCoveringModeCommandParams = new LinkedHashMap(); + CommandParameterInfo windowCoveringmodeCommandParameterInfo = new CommandParameterInfo("value", 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); return writeAttributeMap; } } + diff --git a/zzz_generated/lock-app/zap-generated/IMClusterCommandHandler.cpp b/zzz_generated/lock-app/zap-generated/IMClusterCommandHandler.cpp index 96ed0ea4850124..d02872c26c8738 100644 --- a/zzz_generated/lock-app/zap-generated/IMClusterCommandHandler.cpp +++ b/zzz_generated/lock-app/zap-generated/IMClusterCommandHandler.cpp @@ -151,6 +151,43 @@ void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandP } // namespace DiagnosticLogs +namespace EthernetNetworkDiagnostics { + +void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) +{ + CHIP_ERROR TLVError = CHIP_NO_ERROR; + bool wasHandled = false; + { + switch (aCommandPath.mCommandId) + { + case Commands::ResetCounts::Id: { + Commands::ResetCounts::DecodableType commandData; + TLVError = DataModel::Decode(aDataTlv, commandData); + if (TLVError == CHIP_NO_ERROR) + { + wasHandled = emberAfEthernetNetworkDiagnosticsClusterResetCountsCallback(apCommandObj, aCommandPath, commandData); + } + break; + } + default: { + // Unrecognized command ID, error status will apply. + apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); + ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, + ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); + return; + } + } + } + + if (CHIP_NO_ERROR != TLVError || !wasHandled) + { + apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); + ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); + } +} + +} // namespace EthernetNetworkDiagnostics + namespace GeneralCommissioning { void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) @@ -497,6 +534,117 @@ void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandP } // namespace OperationalCredentials +namespace SoftwareDiagnostics { + +void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) +{ + CHIP_ERROR TLVError = CHIP_NO_ERROR; + bool wasHandled = false; + { + switch (aCommandPath.mCommandId) + { + case Commands::ResetWatermarks::Id: { + Commands::ResetWatermarks::DecodableType commandData; + TLVError = DataModel::Decode(aDataTlv, commandData); + if (TLVError == CHIP_NO_ERROR) + { + wasHandled = emberAfSoftwareDiagnosticsClusterResetWatermarksCallback(apCommandObj, aCommandPath, commandData); + } + break; + } + default: { + // Unrecognized command ID, error status will apply. + apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); + ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, + ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); + return; + } + } + } + + if (CHIP_NO_ERROR != TLVError || !wasHandled) + { + apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); + ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); + } +} + +} // namespace SoftwareDiagnostics + +namespace ThreadNetworkDiagnostics { + +void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) +{ + CHIP_ERROR TLVError = CHIP_NO_ERROR; + bool wasHandled = false; + { + switch (aCommandPath.mCommandId) + { + case Commands::ResetCounts::Id: { + Commands::ResetCounts::DecodableType commandData; + TLVError = DataModel::Decode(aDataTlv, commandData); + if (TLVError == CHIP_NO_ERROR) + { + wasHandled = emberAfThreadNetworkDiagnosticsClusterResetCountsCallback(apCommandObj, aCommandPath, commandData); + } + break; + } + default: { + // Unrecognized command ID, error status will apply. + apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); + ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, + ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); + return; + } + } + } + + if (CHIP_NO_ERROR != TLVError || !wasHandled) + { + apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); + ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); + } +} + +} // namespace ThreadNetworkDiagnostics + +namespace WiFiNetworkDiagnostics { + +void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aDataTlv) +{ + CHIP_ERROR TLVError = CHIP_NO_ERROR; + bool wasHandled = false; + { + switch (aCommandPath.mCommandId) + { + case Commands::ResetCounts::Id: { + Commands::ResetCounts::DecodableType commandData; + TLVError = DataModel::Decode(aDataTlv, commandData); + if (TLVError == CHIP_NO_ERROR) + { + wasHandled = emberAfWiFiNetworkDiagnosticsClusterResetCountsCallback(apCommandObj, aCommandPath, commandData); + } + break; + } + default: { + // Unrecognized command ID, error status will apply. + apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCommand); + ChipLogError(Zcl, "Unknown command " ChipLogFormatMEI " for cluster " ChipLogFormatMEI, + ChipLogValueMEI(aCommandPath.mCommandId), ChipLogValueMEI(aCommandPath.mClusterId)); + return; + } + } + } + + if (CHIP_NO_ERROR != TLVError || !wasHandled) + { + apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::InvalidCommand); + ChipLogProgress(Zcl, "Failed to dispatch command, TLVError=%" CHIP_ERROR_FORMAT, TLVError.Format()); + } +} + +} // namespace WiFiNetworkDiagnostics + } // namespace Clusters void DispatchSingleClusterCommand(const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aReader, CommandHandler * apCommandObj) @@ -511,6 +659,9 @@ void DispatchSingleClusterCommand(const ConcreteCommandPath & aCommandPath, TLV: case Clusters::DiagnosticLogs::Id: Clusters::DiagnosticLogs::DispatchServerCommand(apCommandObj, aCommandPath, aReader); break; + case Clusters::EthernetNetworkDiagnostics::Id: + Clusters::EthernetNetworkDiagnostics::DispatchServerCommand(apCommandObj, aCommandPath, aReader); + break; case Clusters::GeneralCommissioning::Id: Clusters::GeneralCommissioning::DispatchServerCommand(apCommandObj, aCommandPath, aReader); break; @@ -526,6 +677,15 @@ void DispatchSingleClusterCommand(const ConcreteCommandPath & aCommandPath, TLV: case Clusters::OperationalCredentials::Id: Clusters::OperationalCredentials::DispatchServerCommand(apCommandObj, aCommandPath, aReader); break; + case Clusters::SoftwareDiagnostics::Id: + Clusters::SoftwareDiagnostics::DispatchServerCommand(apCommandObj, aCommandPath, aReader); + break; + case Clusters::ThreadNetworkDiagnostics::Id: + Clusters::ThreadNetworkDiagnostics::DispatchServerCommand(apCommandObj, aCommandPath, aReader); + break; + case Clusters::WiFiNetworkDiagnostics::Id: + Clusters::WiFiNetworkDiagnostics::DispatchServerCommand(apCommandObj, aCommandPath, aReader); + break; default: ChipLogError(Zcl, "Unknown cluster " ChipLogFormatMEI, ChipLogValueMEI(aCommandPath.mClusterId)); apCommandObj->AddStatus(aCommandPath, Protocols::InteractionModel::Status::UnsupportedCluster); From 48855a9d6335c4d5990c26b3a7d000e5bd2a8fd8 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Mon, 31 Jan 2022 22:25:14 +0000 Subject: [PATCH 13/14] Restyled by whitespace --- .../chip/devicecontroller/ChipClusters.java | 242 ++-- .../chip/devicecontroller/ChipStructs.java | 2 +- .../devicecontroller/ClusterInfoMapping.java | 1009 ++++++++--------- .../devicecontroller/ClusterReadMapping.java | 1 - .../devicecontroller/ClusterWriteMapping.java | 269 +++-- 5 files changed, 760 insertions(+), 763 deletions(-) diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index bad2cfd7e68797..84244edbcb62c1 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -86,7 +86,7 @@ public BaseChipCluster(long devicePtr, int endpointId) { public abstract long initWithDevice(long devicePtr, int endpointId); public native void deleteCluster(long chipClusterPtr); - + @SuppressWarnings("deprecation") protected void finalize() throws Throwable { super.finalize(); @@ -245,7 +245,7 @@ public void loginRequest(DefaultClusterCallback callback public void logoutRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { logoutRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -256,11 +256,11 @@ private native void loginRequest(long chipClusterPtr, DefaultClusterCallback Cal , String tempAccountIdentifier, String setupPIN , @Nullable Integer timedInvokeTimeoutMs); private native void logoutRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface GetSetupPINResponseCallback { void onSuccess(String setupPIN); - + void onError(Exception error); } @@ -336,7 +336,7 @@ public void openCommissioningWindow(DefaultClusterCallback callback public void revokeCommissioning(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -347,7 +347,7 @@ private native void openCommissioningWindow(long chipClusterPtr, DefaultClusterC , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID , @Nullable Integer timedInvokeTimeoutMs); private native void revokeCommissioning(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AdminFabricIndexAttributeCallback { @@ -703,7 +703,7 @@ private native void stopAppRequest(long chipClusterPtr, LauncherResponseCallback , @Nullable Integer timedInvokeTimeoutMs); public interface LauncherResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } @@ -930,7 +930,7 @@ public void barrierControlStop(DefaultClusterCallback callback } public void barrierControlStop(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { barrierControlStop(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -938,7 +938,7 @@ private native void barrierControlGoToPercent(long chipClusterPtr, DefaultCluste , Integer percentOpen , @Nullable Integer timedInvokeTimeoutMs); private native void barrierControlStop(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -2195,7 +2195,7 @@ private native void skipChannelRequest(long chipClusterPtr, DefaultClusterCallba , @Nullable Integer timedInvokeTimeoutMs); public interface ChangeChannelResponseCallback { void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType); - + void onError(Exception error); } @@ -3734,7 +3734,7 @@ private native void launchURLRequest(long chipClusterPtr, LaunchResponseCallback , @Nullable Integer timedInvokeTimeoutMs); public interface LaunchResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } @@ -4012,7 +4012,7 @@ private native void retrieveLogsRequest(long chipClusterPtr, RetrieveLogsRespons , @Nullable Integer timedInvokeTimeoutMs); public interface RetrieveLogsResponseCallback { void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot); - + void onError(Exception error); } @@ -4236,31 +4236,31 @@ private native void unlockWithTimeout(long chipClusterPtr, DefaultClusterCallbac , @Nullable Integer timedInvokeTimeoutMs); public interface GetCredentialStatusResponseCallback { void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); - + void onError(Exception error); } public interface GetUserResponseCallback { void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex); - + void onError(Exception error); } public interface GetWeekDayScheduleResponseCallback { void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute); - + void onError(Exception error); } public interface GetYearDayScheduleResponseCallback { void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime); - + void onError(Exception error); } public interface SetCredentialResponseCallback { void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); - + void onError(Exception error); } @@ -5062,12 +5062,12 @@ public void resetCounts(DefaultClusterCallback callback } public void resetCounts(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -5542,7 +5542,7 @@ public void commissioningComplete(CommissioningCompleteResponseCallback callback } public void commissioningComplete(CommissioningCompleteResponseCallback callback - + , int timedInvokeTimeoutMs) { commissioningComplete(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -5561,26 +5561,26 @@ private native void armFailSafe(long chipClusterPtr, ArmFailSafeResponseCallback , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs , @Nullable Integer timedInvokeTimeoutMs); private native void commissioningComplete(long chipClusterPtr, CommissioningCompleteResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void setRegulatoryConfig(long chipClusterPtr, SetRegulatoryConfigResponseCallback Callback , Integer location, String countryCode, Long breadcrumb, Long timeoutMs , @Nullable Integer timedInvokeTimeoutMs); public interface ArmFailSafeResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } public interface CommissioningCompleteResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } public interface SetRegulatoryConfigResponseCallback { void onSuccess(Integer errorCode, String debugText); - + void onError(Exception error); } @@ -6014,13 +6014,13 @@ private native void keySetWrite(long chipClusterPtr, DefaultClusterCallback Call , @Nullable Integer timedInvokeTimeoutMs); public interface KeySetReadAllIndicesResponseCallback { void onSuccess(ArrayList groupKeySetIDs); - + void onError(Exception error); } public interface KeySetReadResponseCallback { void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet); - + void onError(Exception error); } @@ -6205,7 +6205,7 @@ public void removeAllGroups(DefaultClusterCallback callback } public void removeAllGroups(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { removeAllGroups(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -6241,7 +6241,7 @@ private native void getGroupMembership(long chipClusterPtr, GetGroupMembershipRe , ArrayList groupList , @Nullable Integer timedInvokeTimeoutMs); private native void removeAllGroups(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void removeGroup(long chipClusterPtr, RemoveGroupResponseCallback Callback , Integer groupId @@ -6251,25 +6251,25 @@ private native void viewGroup(long chipClusterPtr, ViewGroupResponseCallback Cal , @Nullable Integer timedInvokeTimeoutMs); public interface AddGroupResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface GetGroupMembershipResponseCallback { void onSuccess(Integer capacity, ArrayList groupList); - + void onError(Exception error); } public interface RemoveGroupResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface ViewGroupResponseCallback { void onSuccess(Integer status, Integer groupId, String groupName); - + void onError(Exception error); } @@ -6365,7 +6365,7 @@ public void identifyQuery(IdentifyQueryResponseCallback callback } public void identifyQuery(IdentifyQueryResponseCallback callback - + , int timedInvokeTimeoutMs) { identifyQuery(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -6384,14 +6384,14 @@ private native void identify(long chipClusterPtr, DefaultClusterCallback Callbac , Integer identifyTime , @Nullable Integer timedInvokeTimeoutMs); private native void identifyQuery(long chipClusterPtr, IdentifyQueryResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void triggerEffect(long chipClusterPtr, DefaultClusterCallback Callback , Integer effectIdentifier, Integer effectVariant , @Nullable Integer timedInvokeTimeoutMs); public interface IdentifyQueryResponseCallback { void onSuccess(Integer timeout); - + void onError(Exception error); } @@ -6683,7 +6683,7 @@ private native void sendKeyRequest(long chipClusterPtr, SendKeyResponseCallback , @Nullable Integer timedInvokeTimeoutMs); public interface SendKeyResponseCallback { void onSuccess(Integer status); - + void onError(Exception error); } @@ -6826,7 +6826,7 @@ public void stopWithOnOff(DefaultClusterCallback callback } public void stopWithOnOff(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -6852,7 +6852,7 @@ private native void stop(long chipClusterPtr, DefaultClusterCallback Callback , Integer optionMask, Integer optionOverride , @Nullable Integer timedInvokeTimeoutMs); private native void stopWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface OnLevelAttributeCallback { @@ -7372,12 +7372,12 @@ public void sleep(DefaultClusterCallback callback } public void sleep(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { sleep(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void sleep(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -7441,7 +7441,7 @@ public void hideInputStatusRequest(DefaultClusterCallback callback } public void hideInputStatusRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { hideInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7474,12 +7474,12 @@ public void showInputStatusRequest(DefaultClusterCallback callback } public void showInputStatusRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { showInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void hideInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void renameInputRequest(long chipClusterPtr, DefaultClusterCallback Callback , Integer index, String name @@ -7488,7 +7488,7 @@ private native void selectInputRequest(long chipClusterPtr, DefaultClusterCallba , Integer index , @Nullable Integer timedInvokeTimeoutMs); private native void showInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface MediaInputListAttributeCallback { @@ -7595,7 +7595,7 @@ public void fastForwardRequest(PlaybackResponseCallback callback } public void fastForwardRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { fastForwardRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7606,7 +7606,7 @@ public void nextRequest(PlaybackResponseCallback callback } public void nextRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { nextRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7617,7 +7617,7 @@ public void pauseRequest(PlaybackResponseCallback callback } public void pauseRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { pauseRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7628,7 +7628,7 @@ public void playRequest(PlaybackResponseCallback callback } public void playRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { playRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7639,7 +7639,7 @@ public void previousRequest(PlaybackResponseCallback callback } public void previousRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { previousRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7650,7 +7650,7 @@ public void rewindRequest(PlaybackResponseCallback callback } public void rewindRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { rewindRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7694,7 +7694,7 @@ public void startOverRequest(PlaybackResponseCallback callback } public void startOverRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { startOverRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -7705,27 +7705,27 @@ public void stopRequest(PlaybackResponseCallback callback } public void stopRequest(PlaybackResponseCallback callback - + , int timedInvokeTimeoutMs) { stopRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void fastForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void nextRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void pauseRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void playRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void previousRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void rewindRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void seekRequest(long chipClusterPtr, PlaybackResponseCallback Callback , Long position @@ -7737,14 +7737,14 @@ private native void skipForwardRequest(long chipClusterPtr, PlaybackResponseCall , Long deltaPositionMilliseconds , @Nullable Integer timedInvokeTimeoutMs); private native void startOverRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void stopRequest(long chipClusterPtr, PlaybackResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface PlaybackResponseCallback { void onSuccess(Integer status); - + void onError(Exception error); } @@ -8181,19 +8181,19 @@ private native void scanNetworks(long chipClusterPtr, ScanNetworksResponseCallba , @Nullable Integer timedInvokeTimeoutMs); public interface ConnectNetworkResponseCallback { void onSuccess(Integer networkingStatus, String debugText, Long errorValue); - + void onError(Exception error); } public interface NetworkConfigResponseCallback { void onSuccess(Integer networkingStatus, String debugText); - + void onError(Exception error); } public interface ScanNetworksResponseCallback { void onSuccess(Integer networkingStatus, String debugText, Optional> wiFiScanResults, Optional> threadScanResults); - + void onError(Exception error); } @@ -8457,13 +8457,13 @@ private native void queryImage(long chipClusterPtr, QueryImageResponseCallback C , @Nullable Integer timedInvokeTimeoutMs); public interface ApplyUpdateResponseCallback { void onSuccess(Integer action, Long delayedActionTime); - + void onError(Exception error); } public interface QueryImageResponseCallback { void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor); - + void onError(Exception error); } @@ -8805,7 +8805,7 @@ public void off(DefaultClusterCallback callback } public void off(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { off(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -8827,7 +8827,7 @@ public void on(DefaultClusterCallback callback } public void on(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { on(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -8838,7 +8838,7 @@ public void onWithRecallGlobalScene(DefaultClusterCallback callback } public void onWithRecallGlobalScene(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { onWithRecallGlobalScene(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -8860,27 +8860,27 @@ public void toggle(DefaultClusterCallback callback } public void toggle(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { toggle(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void off(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void offWithEffect(long chipClusterPtr, DefaultClusterCallback Callback , Integer effectId, Integer effectVariant , @Nullable Integer timedInvokeTimeoutMs); private native void on(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void onWithRecallGlobalScene(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void onWithTimedOff(long chipClusterPtr, DefaultClusterCallback Callback , Integer onOffControl, Integer onTime, Integer offWaitTime , @Nullable Integer timedInvokeTimeoutMs); private native void toggle(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -9308,25 +9308,25 @@ private native void updateNOC(long chipClusterPtr, NOCResponseCallback Callback , @Nullable Integer timedInvokeTimeoutMs); public interface AttestationResponseCallback { void onSuccess(byte[] attestationElements, byte[] signature); - + void onError(Exception error); } public interface CertificateChainResponseCallback { void onSuccess(byte[] certificate); - + void onError(Exception error); } public interface NOCResponseCallback { void onSuccess(Integer statusCode, Integer fabricIndex, String debugText); - + void onError(Exception error); } public interface OpCSRResponseCallback { void onSuccess(byte[] NOCSRElements, byte[] attestationSignature); - + void onError(Exception error); } @@ -10767,37 +10767,37 @@ private native void viewScene(long chipClusterPtr, ViewSceneResponseCallback Cal , @Nullable Integer timedInvokeTimeoutMs); public interface AddSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface GetSceneMembershipResponseCallback { void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList); - + void onError(Exception error); } public interface RemoveAllScenesResponseCallback { void onSuccess(Integer status, Integer groupId); - + void onError(Exception error); } public interface RemoveSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface StoreSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); - + void onError(Exception error); } public interface ViewSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets); - + void onError(Exception error); } @@ -10958,12 +10958,12 @@ public void resetWatermarks(DefaultClusterCallback callback } public void resetWatermarks(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetWatermarks(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetWatermarks(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface ThreadMetricsAttributeCallback { @@ -11267,7 +11267,7 @@ private native void navigateTargetRequest(long chipClusterPtr, NavigateTargetRes , @Nullable Integer timedInvokeTimeoutMs); public interface NavigateTargetResponseCallback { void onSuccess(Integer status, String data); - + void onError(Exception error); } @@ -11518,7 +11518,7 @@ public void test(DefaultClusterCallback callback } public void test(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { test(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11628,7 +11628,7 @@ public void testNotHandled(DefaultClusterCallback callback } public void testNotHandled(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11661,7 +11661,7 @@ public void testSpecific(TestSpecificResponseCallback callback } public void testSpecific(TestSpecificResponseCallback callback - + , int timedInvokeTimeoutMs) { testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11683,14 +11683,14 @@ public void testUnknownCommand(DefaultClusterCallback callback } public void testUnknownCommand(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); } public void timedInvokeRequest(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -11698,7 +11698,7 @@ private native void simpleStructEchoRequest(long chipClusterPtr, SimpleStructRes , ChipStructs.TestClusterClusterSimpleStruct arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void test(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void testAddArguments(long chipClusterPtr, TestAddArgumentsResponseCallback Callback , Integer arg1, Integer arg2 @@ -11728,7 +11728,7 @@ private native void testNestedStructListArgumentRequest(long chipClusterPtr, Boo , ChipStructs.TestClusterClusterNestedStructList arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void testNotHandled(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void testNullableOptionalRequest(long chipClusterPtr, TestNullableOptionalResponseCallback Callback , @Nullable Optional arg1 @@ -11737,62 +11737,62 @@ private native void testSimpleOptionalArgumentRequest(long chipClusterPtr, Defau , Optional arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void testSpecific(long chipClusterPtr, TestSpecificResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void testStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback , ChipStructs.TestClusterClusterSimpleStruct arg1 , @Nullable Integer timedInvokeTimeoutMs); private native void testUnknownCommand(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void timedInvokeRequest(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface BooleanResponseCallback { void onSuccess(Boolean value); - + void onError(Exception error); } public interface SimpleStructResponseCallback { void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); - + void onError(Exception error); } public interface TestAddArgumentsResponseCallback { void onSuccess(Integer returnValue); - + void onError(Exception error); } public interface TestEmitTestEventResponseCallback { void onSuccess(Long value); - + void onError(Exception error); } public interface TestEnumsResponseCallback { void onSuccess(Integer arg1, Integer arg2); - + void onError(Exception error); } public interface TestListInt8UReverseResponseCallback { void onSuccess(ArrayList arg1); - + void onError(Exception error); } public interface TestNullableOptionalResponseCallback { void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue); - + void onError(Exception error); } public interface TestSpecificResponseCallback { void onSuccess(Integer returnValue); - + void onError(Exception error); } @@ -14220,7 +14220,7 @@ public void clearWeeklySchedule(DefaultClusterCallback callback } public void clearWeeklySchedule(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { clearWeeklySchedule(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -14231,7 +14231,7 @@ public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback } public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback - + , int timedInvokeTimeoutMs) { getRelayStatusLog(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -14269,10 +14269,10 @@ public void setpointRaiseLower(DefaultClusterCallback callback setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs); } private native void clearWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void getRelayStatusLog(long chipClusterPtr, GetRelayStatusLogResponseCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void getWeeklySchedule(long chipClusterPtr, GetWeeklyScheduleResponseCallback Callback , Integer daysToReturn, Integer modeToReturn @@ -14285,13 +14285,13 @@ private native void setpointRaiseLower(long chipClusterPtr, DefaultClusterCallba , @Nullable Integer timedInvokeTimeoutMs); public interface GetRelayStatusLogResponseCallback { void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries); - + void onError(Exception error); } public interface GetWeeklyScheduleResponseCallback { void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload); - + void onError(Exception error); } @@ -14919,12 +14919,12 @@ public void resetCounts(DefaultClusterCallback callback } public void resetCounts(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface NeighborTableListAttributeCallback { @@ -16556,12 +16556,12 @@ public void resetCounts(DefaultClusterCallback callback } public void resetCounts(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface AttributeListAttributeCallback { @@ -16891,7 +16891,7 @@ public void downOrClose(DefaultClusterCallback callback } public void downOrClose(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { downOrClose(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -16946,7 +16946,7 @@ public void stopMotion(DefaultClusterCallback callback } public void stopMotion(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { stopMotion(chipClusterPtr, callback, timedInvokeTimeoutMs); } @@ -16957,12 +16957,12 @@ public void upOrOpen(DefaultClusterCallback callback } public void upOrOpen(DefaultClusterCallback callback - + , int timedInvokeTimeoutMs) { upOrOpen(chipClusterPtr, callback, timedInvokeTimeoutMs); } private native void downOrClose(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void goToLiftPercentage(long chipClusterPtr, DefaultClusterCallback Callback , Integer liftPercentageValue, Integer liftPercent100thsValue @@ -16977,10 +16977,10 @@ private native void goToTiltValue(long chipClusterPtr, DefaultClusterCallback Ca , Integer tiltValue , @Nullable Integer timedInvokeTimeoutMs); private native void stopMotion(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); private native void upOrOpen(long chipClusterPtr, DefaultClusterCallback Callback - + , @Nullable Integer timedInvokeTimeoutMs); public interface CurrentPositionLiftAttributeCallback { diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java index 23446754ab399f..19853055a448c2 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java @@ -2130,4 +2130,4 @@ public String toString() { } } -} \ No newline at end of file +} diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index 206c331e05b755..36b3755afb50ea 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -1024,7 +1024,7 @@ public void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Lo responseValues.put(userTypeResponseValue, userType); CommandResponseInfo credentialRuleResponseValue = new CommandResponseInfo("credentialRule", "Integer"); responseValues.put(credentialRuleResponseValue, credentialRule); - // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * + // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet CommandResponseInfo creatorFabricIndexResponseValue = new CommandResponseInfo("creatorFabricIndex", "Integer"); responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); @@ -1479,7 +1479,7 @@ public void setCallbackDelegate(ClusterCommandCallback callback) { @Override public void onSuccess(ArrayList groupKeySetIDs) { Map responseValues = new LinkedHashMap<>(); - // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * + // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -1609,7 +1609,7 @@ public void onSuccess(Integer capacity, ArrayList groupList) { Map responseValues = new LinkedHashMap<>(); CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); responseValues.put(capacityResponseValue, capacity); - // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * + // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -2045,9 +2045,9 @@ public void onSuccess(Integer NetworkingStatus, String DebugText, Optional arg1) { Map responseValues = new LinkedHashMap<>(); - // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * + // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -3258,7 +3258,7 @@ public void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekF responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); CommandResponseInfo modeForSequenceResponseValue = new CommandResponseInfo("modeForSequence", "Integer"); responseValues.put(modeForSequenceResponseValue, modeForSequence); - // payload: /* TYPE WARNING: array array defaults to */ uint8_t * + // payload: /* TYPE WARNING: array array defaults to */ uint8_t * // Conversion from this type to Java is not properly implemented yet callback.onSuccess(responseValues); } @@ -3824,7 +3824,7 @@ public Map> getCommandMap() { Map accountLogingetSetupPINRequestCommandParams = new LinkedHashMap(); CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); accountLogingetSetupPINRequestCommandParams.put("tempAccountIdentifier",accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); - + InteractionInfo accountLogingetSetupPINRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AccountLoginCluster) cluster) @@ -3841,10 +3841,10 @@ public Map> getCommandMap() { Map accountLoginloginRequestCommandParams = new LinkedHashMap(); CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); accountLoginloginRequestCommandParams.put("tempAccountIdentifier",accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); - + CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = new CommandParameterInfo("setupPIN", String.class); accountLoginloginRequestCommandParams.put("setupPIN",accountLoginloginRequestsetupPINCommandParameterInfo); - + InteractionInfo accountLoginloginRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AccountLoginCluster) cluster) @@ -3877,7 +3877,7 @@ public Map> getCommandMap() { Map administratorCommissioningopenBasicCommissioningWindowCommandParams = new LinkedHashMap(); CommandParameterInfo administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); administratorCommissioningopenBasicCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); - + InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AdministratorCommissioningCluster) cluster) @@ -3894,22 +3894,22 @@ public Map> getCommandMap() { Map administratorCommissioningopenCommissioningWindowCommandParams = new LinkedHashMap(); CommandParameterInfo administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); administratorCommissioningopenCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = new CommandParameterInfo("PAKEVerifier", byte[].class); administratorCommissioningopenCommissioningWindowCommandParams.put("PAKEVerifier",administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = new CommandParameterInfo("discriminator", Integer.class); administratorCommissioningopenCommissioningWindowCommandParams.put("discriminator",administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = new CommandParameterInfo("iterations", Long.class); administratorCommissioningopenCommissioningWindowCommandParams.put("iterations",administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = new CommandParameterInfo("salt", byte[].class); administratorCommissioningopenCommissioningWindowCommandParams.put("salt",administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); - + CommandParameterInfo administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = new CommandParameterInfo("passcodeID", Integer.class); administratorCommissioningopenCommissioningWindowCommandParams.put("passcodeID",administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); - + InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AdministratorCommissioningCluster) cluster) @@ -3956,7 +3956,7 @@ public Map> getCommandMap() { .hideAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) commandArguments.get("application") - + ); }, () -> new DelegatedLauncherResponseCallback(), @@ -3966,7 +3966,7 @@ public Map> getCommandMap() { Map applicationLauncherlaunchAppRequestCommandParams = new LinkedHashMap(); CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); applicationLauncherlaunchAppRequestCommandParams.put("data",applicationLauncherlaunchAppRequestdataCommandParameterInfo); - + InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ApplicationLauncherCluster) cluster) @@ -3975,7 +3975,7 @@ public Map> getCommandMap() { commandArguments.get("data") , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) commandArguments.get("application") - + ); }, () -> new DelegatedLauncherResponseCallback(), @@ -3989,7 +3989,7 @@ public Map> getCommandMap() { .stopAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) commandArguments.get("application") - + ); }, () -> new DelegatedLauncherResponseCallback(), @@ -4001,10 +4001,10 @@ public Map> getCommandMap() { Map audioOutputrenameOutputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); audioOutputrenameOutputRequestCommandParams.put("index",audioOutputrenameOutputRequestindexCommandParameterInfo); - + CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); audioOutputrenameOutputRequestCommandParams.put("name",audioOutputrenameOutputRequestnameCommandParameterInfo); - + InteractionInfo audioOutputrenameOutputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AudioOutputCluster) cluster) @@ -4013,7 +4013,7 @@ public Map> getCommandMap() { commandArguments.get("index") , (String) commandArguments.get("name") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4023,14 +4023,14 @@ public Map> getCommandMap() { Map audioOutputselectOutputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); audioOutputselectOutputRequestCommandParams.put("index",audioOutputselectOutputRequestindexCommandParameterInfo); - + InteractionInfo audioOutputselectOutputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.AudioOutputCluster) cluster) .selectOutputRequest((DefaultClusterCallback) callback , (Integer) commandArguments.get("index") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4042,14 +4042,14 @@ public Map> getCommandMap() { Map barrierControlbarrierControlGoToPercentCommandParams = new LinkedHashMap(); CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = new CommandParameterInfo("percentOpen", Integer.class); barrierControlbarrierControlGoToPercentCommandParams.put("percentOpen",barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); - + InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .barrierControlGoToPercent((DefaultClusterCallback) callback , (Integer) commandArguments.get("percentOpen") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4061,7 +4061,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.BarrierControlCluster) cluster) .barrierControlStop((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4077,16 +4077,16 @@ public Map> getCommandMap() { Map bindingbindCommandParams = new LinkedHashMap(); CommandParameterInfo bindingbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); bindingbindCommandParams.put("nodeId",bindingbindnodeIdCommandParameterInfo); - + CommandParameterInfo bindingbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); bindingbindCommandParams.put("groupId",bindingbindgroupIdCommandParameterInfo); - + CommandParameterInfo bindingbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); bindingbindCommandParams.put("endpointId",bindingbindendpointIdCommandParameterInfo); - + CommandParameterInfo bindingbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); bindingbindCommandParams.put("clusterId",bindingbindclusterIdCommandParameterInfo); - + InteractionInfo bindingbindInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BindingCluster) cluster) @@ -4099,7 +4099,7 @@ public Map> getCommandMap() { commandArguments.get("endpointId") , (Long) commandArguments.get("clusterId") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4109,16 +4109,16 @@ public Map> getCommandMap() { Map bindingunbindCommandParams = new LinkedHashMap(); CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); bindingunbindCommandParams.put("nodeId",bindingunbindnodeIdCommandParameterInfo); - + CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); bindingunbindCommandParams.put("groupId",bindingunbindgroupIdCommandParameterInfo); - + CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); bindingunbindCommandParams.put("endpointId",bindingunbindendpointIdCommandParameterInfo); - + CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); bindingunbindCommandParams.put("clusterId",bindingunbindclusterIdCommandParameterInfo); - + InteractionInfo bindingunbindInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BindingCluster) cluster) @@ -4131,7 +4131,7 @@ public Map> getCommandMap() { commandArguments.get("endpointId") , (Long) commandArguments.get("clusterId") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4145,10 +4145,10 @@ public Map> getCommandMap() { Map bridgedActionsdisableActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsdisableActionCommandParams.put("actionID",bridgedActionsdisableActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsdisableActionCommandParams.put("invokeID",bridgedActionsdisableActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsdisableActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4157,7 +4157,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4167,13 +4167,13 @@ public Map> getCommandMap() { Map bridgedActionsdisableActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsdisableActionWithDurationCommandParams.put("actionID",bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsdisableActionWithDurationCommandParams.put("invokeID",bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionsdisableActionWithDurationCommandParams.put("duration",bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4184,7 +4184,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4194,10 +4194,10 @@ public Map> getCommandMap() { Map bridgedActionsenableActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsenableActionCommandParams.put("actionID",bridgedActionsenableActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsenableActionCommandParams.put("invokeID",bridgedActionsenableActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsenableActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4206,7 +4206,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4216,13 +4216,13 @@ public Map> getCommandMap() { Map bridgedActionsenableActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsenableActionWithDurationCommandParams.put("actionID",bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsenableActionWithDurationCommandParams.put("invokeID",bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionsenableActionWithDurationCommandParams.put("duration",bridgedActionsenableActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4233,7 +4233,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4243,10 +4243,10 @@ public Map> getCommandMap() { Map bridgedActionsinstantActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsinstantActionCommandParams.put("actionID",bridgedActionsinstantActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsinstantActionCommandParams.put("invokeID",bridgedActionsinstantActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsinstantActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4255,7 +4255,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4265,13 +4265,13 @@ public Map> getCommandMap() { Map bridgedActionsinstantActionWithTransitionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsinstantActionWithTransitionCommandParams.put("actionID",bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsinstantActionWithTransitionCommandParams.put("invokeID",bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); bridgedActionsinstantActionWithTransitionCommandParams.put("transitionTime",bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); - + InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4282,7 +4282,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4292,10 +4292,10 @@ public Map> getCommandMap() { Map bridgedActionspauseActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionspauseActionCommandParams.put("actionID",bridgedActionspauseActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionspauseActionCommandParams.put("invokeID",bridgedActionspauseActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionspauseActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4304,7 +4304,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4314,13 +4314,13 @@ public Map> getCommandMap() { Map bridgedActionspauseActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionspauseActionWithDurationCommandParams.put("actionID",bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionspauseActionWithDurationCommandParams.put("invokeID",bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionspauseActionWithDurationCommandParams.put("duration",bridgedActionspauseActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4331,7 +4331,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4341,10 +4341,10 @@ public Map> getCommandMap() { Map bridgedActionsresumeActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsresumeActionCommandParams.put("actionID",bridgedActionsresumeActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsresumeActionCommandParams.put("invokeID",bridgedActionsresumeActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsresumeActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4353,7 +4353,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4363,10 +4363,10 @@ public Map> getCommandMap() { Map bridgedActionsstartActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsstartActionCommandParams.put("actionID",bridgedActionsstartActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsstartActionCommandParams.put("invokeID",bridgedActionsstartActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsstartActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4375,7 +4375,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4385,13 +4385,13 @@ public Map> getCommandMap() { Map bridgedActionsstartActionWithDurationCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsstartActionWithDurationCommandParams.put("actionID",bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsstartActionWithDurationCommandParams.put("invokeID",bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); bridgedActionsstartActionWithDurationCommandParams.put("duration",bridgedActionsstartActionWithDurationdurationCommandParameterInfo); - + InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4402,7 +4402,7 @@ public Map> getCommandMap() { commandArguments.get("invokeID") , (Long) commandArguments.get("duration") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4412,10 +4412,10 @@ public Map> getCommandMap() { Map bridgedActionsstopActionCommandParams = new LinkedHashMap(); CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); bridgedActionsstopActionCommandParams.put("actionID",bridgedActionsstopActionactionIDCommandParameterInfo); - + CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); bridgedActionsstopActionCommandParams.put("invokeID",bridgedActionsstopActioninvokeIDCommandParameterInfo); - + InteractionInfo bridgedActionsstopActionInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.BridgedActionsCluster) cluster) @@ -4424,7 +4424,7 @@ public Map> getCommandMap() { commandArguments.get("actionID") , (Optional) commandArguments.get("invokeID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4438,10 +4438,10 @@ public Map> getCommandMap() { Map channelchangeChannelByNumberRequestCommandParams = new LinkedHashMap(); CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = new CommandParameterInfo("majorNumber", Integer.class); channelchangeChannelByNumberRequestCommandParams.put("majorNumber",channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); - + CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = new CommandParameterInfo("minorNumber", Integer.class); channelchangeChannelByNumberRequestCommandParams.put("minorNumber",channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); - + InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ChannelCluster) cluster) @@ -4450,7 +4450,7 @@ public Map> getCommandMap() { commandArguments.get("majorNumber") , (Integer) commandArguments.get("minorNumber") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4460,14 +4460,14 @@ public Map> getCommandMap() { Map channelchangeChannelRequestCommandParams = new LinkedHashMap(); CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = new CommandParameterInfo("match", String.class); channelchangeChannelRequestCommandParams.put("match",channelchangeChannelRequestmatchCommandParameterInfo); - + InteractionInfo channelchangeChannelRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ChannelCluster) cluster) .changeChannelRequest((ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback , (String) commandArguments.get("match") - + ); }, () -> new DelegatedChangeChannelResponseCallback(), @@ -4477,14 +4477,14 @@ public Map> getCommandMap() { Map channelskipChannelRequestCommandParams = new LinkedHashMap(); CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = new CommandParameterInfo("count", Integer.class); channelskipChannelRequestCommandParams.put("count",channelskipChannelRequestcountCommandParameterInfo); - + InteractionInfo channelskipChannelRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ChannelCluster) cluster) .skipChannelRequest((DefaultClusterCallback) callback , (Integer) commandArguments.get("count") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4496,25 +4496,25 @@ public Map> getCommandMap() { Map colorControlcolorLoopSetCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = new CommandParameterInfo("updateFlags", Integer.class); colorControlcolorLoopSetCommandParams.put("updateFlags",colorControlcolorLoopSetupdateFlagsCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = new CommandParameterInfo("action", Integer.class); colorControlcolorLoopSetCommandParams.put("action",colorControlcolorLoopSetactionCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); colorControlcolorLoopSetCommandParams.put("direction",colorControlcolorLoopSetdirectionCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = new CommandParameterInfo("time", Integer.class); colorControlcolorLoopSetCommandParams.put("time",colorControlcolorLoopSettimeCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = new CommandParameterInfo("startHue", Integer.class); colorControlcolorLoopSetCommandParams.put("startHue",colorControlcolorLoopSetstartHueCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlcolorLoopSetCommandParams.put("optionsMask",colorControlcolorLoopSetoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlcolorLoopSetCommandParams.put("optionsOverride",colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlcolorLoopSetInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4533,7 +4533,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4543,16 +4543,16 @@ public Map> getCommandMap() { Map colorControlenhancedMoveHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlenhancedMoveHueCommandParams.put("moveMode",colorControlenhancedMoveHuemoveModeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlenhancedMoveHueCommandParams.put("rate",colorControlenhancedMoveHuerateCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedMoveHueCommandParams.put("optionsMask",colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedMoveHueCommandParams.put("optionsOverride",colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedMoveHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4565,7 +4565,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4575,19 +4575,19 @@ public Map> getCommandMap() { Map colorControlenhancedMoveToHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); colorControlenhancedMoveToHueCommandParams.put("enhancedHue",colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); colorControlenhancedMoveToHueCommandParams.put("direction",colorControlenhancedMoveToHuedirectionCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlenhancedMoveToHueCommandParams.put("transitionTime",colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedMoveToHueCommandParams.put("optionsMask",colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedMoveToHueCommandParams.put("optionsOverride",colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedMoveToHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4602,7 +4602,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4612,19 +4612,19 @@ public Map> getCommandMap() { Map colorControlenhancedMoveToHueAndSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("enhancedHue",colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("saturation",colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("transitionTime",colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsMask",colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4639,7 +4639,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4649,19 +4649,19 @@ public Map> getCommandMap() { Map colorControlenhancedStepHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlenhancedStepHueCommandParams.put("stepMode",colorControlenhancedStepHuestepModeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlenhancedStepHueCommandParams.put("stepSize",colorControlenhancedStepHuestepSizeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlenhancedStepHueCommandParams.put("transitionTime",colorControlenhancedStepHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlenhancedStepHueCommandParams.put("optionsMask",colorControlenhancedStepHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlenhancedStepHueCommandParams.put("optionsOverride",colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlenhancedStepHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4676,7 +4676,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4686,16 +4686,16 @@ public Map> getCommandMap() { Map colorControlmoveColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = new CommandParameterInfo("rateX", Integer.class); colorControlmoveColorCommandParams.put("rateX",colorControlmoveColorrateXCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = new CommandParameterInfo("rateY", Integer.class); colorControlmoveColorCommandParams.put("rateY",colorControlmoveColorrateYCommandParameterInfo); - + CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveColorCommandParams.put("optionsMask",colorControlmoveColoroptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveColorCommandParams.put("optionsOverride",colorControlmoveColoroptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveColorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4708,7 +4708,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4718,22 +4718,22 @@ public Map> getCommandMap() { Map colorControlmoveColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlmoveColorTemperatureCommandParams.put("moveMode",colorControlmoveColorTemperaturemoveModeCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlmoveColorTemperatureCommandParams.put("rate",colorControlmoveColorTemperaturerateCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveColorTemperatureCommandParams.put("optionsMask",colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveColorTemperatureCommandParams.put("optionsOverride",colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveColorTemperatureInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4750,7 +4750,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4760,16 +4760,16 @@ public Map> getCommandMap() { Map colorControlmoveHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlmoveHueCommandParams.put("moveMode",colorControlmoveHuemoveModeCommandParameterInfo); - + CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlmoveHueCommandParams.put("rate",colorControlmoveHuerateCommandParameterInfo); - + CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveHueCommandParams.put("optionsMask",colorControlmoveHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveHueCommandParams.put("optionsOverride",colorControlmoveHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4782,7 +4782,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4792,16 +4792,16 @@ public Map> getCommandMap() { Map colorControlmoveSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); colorControlmoveSaturationCommandParams.put("moveMode",colorControlmoveSaturationmoveModeCommandParameterInfo); - + CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); colorControlmoveSaturationCommandParams.put("rate",colorControlmoveSaturationrateCommandParameterInfo); - + CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveSaturationCommandParams.put("optionsMask",colorControlmoveSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveSaturationCommandParams.put("optionsOverride",colorControlmoveSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4814,7 +4814,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4824,19 +4824,19 @@ public Map> getCommandMap() { Map colorControlmoveToColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = new CommandParameterInfo("colorX", Integer.class); colorControlmoveToColorCommandParams.put("colorX",colorControlmoveToColorcolorXCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = new CommandParameterInfo("colorY", Integer.class); colorControlmoveToColorCommandParams.put("colorY",colorControlmoveToColorcolorYCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToColorCommandParams.put("transitionTime",colorControlmoveToColortransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToColorCommandParams.put("optionsMask",colorControlmoveToColoroptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToColorCommandParams.put("optionsOverride",colorControlmoveToColoroptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToColorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4851,7 +4851,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4861,16 +4861,16 @@ public Map> getCommandMap() { Map colorControlmoveToColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = new CommandParameterInfo("colorTemperature", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("colorTemperature",colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("transitionTime",colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("optionsMask",colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToColorTemperatureCommandParams.put("optionsOverride",colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4883,7 +4883,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4893,19 +4893,19 @@ public Map> getCommandMap() { Map colorControlmoveToHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); colorControlmoveToHueCommandParams.put("hue",colorControlmoveToHuehueCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); colorControlmoveToHueCommandParams.put("direction",colorControlmoveToHuedirectionCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToHueCommandParams.put("transitionTime",colorControlmoveToHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToHueCommandParams.put("optionsMask",colorControlmoveToHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToHueCommandParams.put("optionsOverride",colorControlmoveToHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4920,7 +4920,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4930,19 +4930,19 @@ public Map> getCommandMap() { Map colorControlmoveToHueAndSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("hue",colorControlmoveToHueAndSaturationhueCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("saturation",colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("transitionTime",colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("optionsMask",colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4957,7 +4957,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4967,16 +4967,16 @@ public Map> getCommandMap() { Map colorControlmoveToSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); colorControlmoveToSaturationCommandParams.put("saturation",colorControlmoveToSaturationsaturationCommandParameterInfo); - + CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlmoveToSaturationCommandParams.put("transitionTime",colorControlmoveToSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlmoveToSaturationCommandParams.put("optionsMask",colorControlmoveToSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlmoveToSaturationCommandParams.put("optionsOverride",colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlmoveToSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -4989,7 +4989,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -4999,19 +4999,19 @@ public Map> getCommandMap() { Map colorControlstepColorCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = new CommandParameterInfo("stepX", Integer.class); colorControlstepColorCommandParams.put("stepX",colorControlstepColorstepXCommandParameterInfo); - + CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = new CommandParameterInfo("stepY", Integer.class); colorControlstepColorCommandParams.put("stepY",colorControlstepColorstepYCommandParameterInfo); - + CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepColorCommandParams.put("transitionTime",colorControlstepColortransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepColorCommandParams.put("optionsMask",colorControlstepColoroptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepColorCommandParams.put("optionsOverride",colorControlstepColoroptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepColorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5026,7 +5026,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5036,25 +5036,25 @@ public Map> getCommandMap() { Map colorControlstepColorTemperatureCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlstepColorTemperatureCommandParams.put("stepMode",colorControlstepColorTemperaturestepModeCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlstepColorTemperatureCommandParams.put("stepSize",colorControlstepColorTemperaturestepSizeCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepColorTemperatureCommandParams.put("transitionTime",colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); colorControlstepColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); colorControlstepColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepColorTemperatureCommandParams.put("optionsMask",colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepColorTemperatureCommandParams.put("optionsOverride",colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepColorTemperatureInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5073,7 +5073,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5083,19 +5083,19 @@ public Map> getCommandMap() { Map colorControlstepHueCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlstepHueCommandParams.put("stepMode",colorControlstepHuestepModeCommandParameterInfo); - + CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlstepHueCommandParams.put("stepSize",colorControlstepHuestepSizeCommandParameterInfo); - + CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepHueCommandParams.put("transitionTime",colorControlstepHuetransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepHueCommandParams.put("optionsMask",colorControlstepHueoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepHueCommandParams.put("optionsOverride",colorControlstepHueoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepHueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5110,7 +5110,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5120,19 +5120,19 @@ public Map> getCommandMap() { Map colorControlstepSaturationCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); colorControlstepSaturationCommandParams.put("stepMode",colorControlstepSaturationstepModeCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); colorControlstepSaturationCommandParams.put("stepSize",colorControlstepSaturationstepSizeCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); colorControlstepSaturationCommandParams.put("transitionTime",colorControlstepSaturationtransitionTimeCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstepSaturationCommandParams.put("optionsMask",colorControlstepSaturationoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstepSaturationCommandParams.put("optionsOverride",colorControlstepSaturationoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstepSaturationInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5147,7 +5147,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5157,10 +5157,10 @@ public Map> getCommandMap() { Map colorControlstopMoveStepCommandParams = new LinkedHashMap(); CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); colorControlstopMoveStepCommandParams.put("optionsMask",colorControlstopMoveStepoptionsMaskCommandParameterInfo); - + CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); colorControlstopMoveStepCommandParams.put("optionsOverride",colorControlstopMoveStepoptionsOverrideCommandParameterInfo); - + InteractionInfo colorControlstopMoveStepInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ColorControlCluster) cluster) @@ -5169,7 +5169,7 @@ public Map> getCommandMap() { commandArguments.get("optionsMask") , (Integer) commandArguments.get("optionsOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5181,10 +5181,10 @@ public Map> getCommandMap() { Map contentLauncherlaunchContentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = new CommandParameterInfo("autoPlay", Boolean.class); contentLauncherlaunchContentRequestCommandParams.put("autoPlay",contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); - + CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); contentLauncherlaunchContentRequestCommandParams.put("data",contentLauncherlaunchContentRequestdataCommandParameterInfo); - + InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ContentLauncherCluster) cluster) @@ -5195,7 +5195,7 @@ public Map> getCommandMap() { commandArguments.get("data") , (ArrayList) commandArguments.get("search") - + ); }, () -> new DelegatedLaunchResponseCallback(), @@ -5205,10 +5205,10 @@ public Map> getCommandMap() { Map contentLauncherlaunchURLRequestCommandParams = new LinkedHashMap(); CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = new CommandParameterInfo("contentURL", String.class); contentLauncherlaunchURLRequestCommandParams.put("contentURL",contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); - + CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = new CommandParameterInfo("displayString", String.class); contentLauncherlaunchURLRequestCommandParams.put("displayString",contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); - + InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ContentLauncherCluster) cluster) @@ -5219,7 +5219,7 @@ public Map> getCommandMap() { commandArguments.get("displayString") , (ChipStructs.ContentLauncherClusterBrandingInformation) commandArguments.get("brandingInformation") - + ); }, () -> new DelegatedLaunchResponseCallback(), @@ -5233,13 +5233,13 @@ public Map> getCommandMap() { Map diagnosticLogsretrieveLogsRequestCommandParams = new LinkedHashMap(); CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = new CommandParameterInfo("intent", Integer.class); diagnosticLogsretrieveLogsRequestCommandParams.put("intent",diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); - + CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = new CommandParameterInfo("requestedProtocol", Integer.class); diagnosticLogsretrieveLogsRequestCommandParams.put("requestedProtocol",diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); - + CommandParameterInfo diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = new CommandParameterInfo("transferFileDesignator", byte[].class); diagnosticLogsretrieveLogsRequestCommandParams.put("transferFileDesignator",diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); - + InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DiagnosticLogsCluster) cluster) @@ -5250,7 +5250,7 @@ public Map> getCommandMap() { commandArguments.get("requestedProtocol") , (byte[]) commandArguments.get("transferFileDesignator") - + ); }, () -> new DelegatedRetrieveLogsResponseCallback(), @@ -5276,7 +5276,7 @@ public Map> getCommandMap() { Map doorLockclearUserCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockclearUserCommandParams.put("userIndex",doorLockclearUseruserIndexCommandParameterInfo); - + InteractionInfo doorLockclearUserInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5293,10 +5293,10 @@ public Map> getCommandMap() { Map doorLockclearWeekDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); doorLockclearWeekDayScheduleCommandParams.put("weekDayIndex",doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockclearWeekDayScheduleCommandParams.put("userIndex",doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5305,7 +5305,7 @@ public Map> getCommandMap() { commandArguments.get("weekDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5315,10 +5315,10 @@ public Map> getCommandMap() { Map doorLockclearYearDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); doorLockclearYearDayScheduleCommandParams.put("yearDayIndex",doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockclearYearDayScheduleCommandParams.put("userIndex",doorLockclearYearDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockclearYearDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5327,7 +5327,7 @@ public Map> getCommandMap() { commandArguments.get("yearDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5341,7 +5341,7 @@ public Map> getCommandMap() { .getCredentialStatus((ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback , (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential") - + ); }, () -> new DelegatedGetCredentialStatusResponseCallback(), @@ -5351,14 +5351,14 @@ public Map> getCommandMap() { Map doorLockgetUserCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockgetUserCommandParams.put("userIndex",doorLockgetUseruserIndexCommandParameterInfo); - + InteractionInfo doorLockgetUserInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) .getUser((ChipClusters.DoorLockCluster.GetUserResponseCallback) callback , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedGetUserResponseCallback(), @@ -5368,10 +5368,10 @@ public Map> getCommandMap() { Map doorLockgetWeekDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); doorLockgetWeekDayScheduleCommandParams.put("weekDayIndex",doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockgetWeekDayScheduleCommandParams.put("userIndex",doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5380,7 +5380,7 @@ public Map> getCommandMap() { commandArguments.get("weekDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedGetWeekDayScheduleResponseCallback(), @@ -5390,10 +5390,10 @@ public Map> getCommandMap() { Map doorLockgetYearDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); doorLockgetYearDayScheduleCommandParams.put("yearDayIndex",doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); - + CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLockgetYearDayScheduleCommandParams.put("userIndex",doorLockgetYearDayScheduleuserIndexCommandParameterInfo); - + InteractionInfo doorLockgetYearDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5402,7 +5402,7 @@ public Map> getCommandMap() { commandArguments.get("yearDayIndex") , (Integer) commandArguments.get("userIndex") - + ); }, () -> new DelegatedGetYearDayScheduleResponseCallback(), @@ -5412,7 +5412,7 @@ public Map> getCommandMap() { Map doorLocklockDoorCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); doorLocklockDoorCommandParams.put("pinCode",doorLocklockDoorpinCodeCommandParameterInfo); - + InteractionInfo doorLocklockDoorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5429,19 +5429,19 @@ public Map> getCommandMap() { Map doorLocksetCredentialCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); doorLocksetCredentialCommandParams.put("operationType",doorLocksetCredentialoperationTypeCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = new CommandParameterInfo("credentialData", byte[].class); doorLocksetCredentialCommandParams.put("credentialData",doorLocksetCredentialcredentialDataCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetCredentialCommandParams.put("userIndex",doorLocksetCredentialuserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); doorLocksetCredentialCommandParams.put("userStatus",doorLocksetCredentialuserStatusCommandParameterInfo); - + CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); doorLocksetCredentialCommandParams.put("userType",doorLocksetCredentialuserTypeCommandParameterInfo); - + InteractionInfo doorLocksetCredentialInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5468,25 +5468,25 @@ public Map> getCommandMap() { Map doorLocksetUserCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); doorLocksetUserCommandParams.put("operationType",doorLocksetUseroperationTypeCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetUserCommandParams.put("userIndex",doorLocksetUseruserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = new CommandParameterInfo("userName", String.class); doorLocksetUserCommandParams.put("userName",doorLocksetUseruserNameCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = new CommandParameterInfo("userUniqueId", Long.class); doorLocksetUserCommandParams.put("userUniqueId",doorLocksetUseruserUniqueIdCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); doorLocksetUserCommandParams.put("userStatus",doorLocksetUseruserStatusCommandParameterInfo); - + CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); doorLocksetUserCommandParams.put("userType",doorLocksetUseruserTypeCommandParameterInfo); - + CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = new CommandParameterInfo("credentialRule", Integer.class); doorLocksetUserCommandParams.put("credentialRule",doorLocksetUsercredentialRuleCommandParameterInfo); - + InteractionInfo doorLocksetUserInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5515,25 +5515,25 @@ public Map> getCommandMap() { Map doorLocksetWeekDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("weekDayIndex",doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("userIndex",doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = new CommandParameterInfo("daysMask", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("daysMask",doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = new CommandParameterInfo("startHour", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("startHour",doorLocksetWeekDaySchedulestartHourCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = new CommandParameterInfo("startMinute", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("startMinute",doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = new CommandParameterInfo("endHour", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("endHour",doorLocksetWeekDayScheduleendHourCommandParameterInfo); - + CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = new CommandParameterInfo("endMinute", Integer.class); doorLocksetWeekDayScheduleCommandParams.put("endMinute",doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); - + InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5552,7 +5552,7 @@ public Map> getCommandMap() { commandArguments.get("endHour") , (Integer) commandArguments.get("endMinute") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5562,16 +5562,16 @@ public Map> getCommandMap() { Map doorLocksetYearDayScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); doorLocksetYearDayScheduleCommandParams.put("yearDayIndex",doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); doorLocksetYearDayScheduleCommandParams.put("userIndex",doorLocksetYearDayScheduleuserIndexCommandParameterInfo); - + CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = new CommandParameterInfo("localStartTime", Long.class); doorLocksetYearDayScheduleCommandParams.put("localStartTime",doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); - + CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = new CommandParameterInfo("localEndTime", Long.class); doorLocksetYearDayScheduleCommandParams.put("localEndTime",doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); - + InteractionInfo doorLocksetYearDayScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5584,7 +5584,7 @@ public Map> getCommandMap() { commandArguments.get("localStartTime") , (Long) commandArguments.get("localEndTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5594,7 +5594,7 @@ public Map> getCommandMap() { Map doorLockunlockDoorCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); doorLockunlockDoorCommandParams.put("pinCode",doorLockunlockDoorpinCodeCommandParameterInfo); - + InteractionInfo doorLockunlockDoorInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5611,10 +5611,10 @@ public Map> getCommandMap() { Map doorLockunlockWithTimeoutCommandParams = new LinkedHashMap(); CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = new CommandParameterInfo("timeout", Integer.class); doorLockunlockWithTimeoutCommandParams.put("timeout",doorLockunlockWithTimeouttimeoutCommandParameterInfo); - + CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); doorLockunlockWithTimeoutCommandParams.put("pinCode",doorLockunlockWithTimeoutpinCodeCommandParameterInfo); - + InteractionInfo doorLockunlockWithTimeoutInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.DoorLockCluster) cluster) @@ -5639,7 +5639,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) .resetCounts((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5655,13 +5655,13 @@ public Map> getCommandMap() { Map generalCommissioningarmFailSafeCommandParams = new LinkedHashMap(); CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = new CommandParameterInfo("expiryLengthSeconds", Integer.class); generalCommissioningarmFailSafeCommandParams.put("expiryLengthSeconds",generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); - + CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); generalCommissioningarmFailSafeCommandParams.put("breadcrumb",generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); - + CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); generalCommissioningarmFailSafeCommandParams.put("timeoutMs",generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); - + InteractionInfo generalCommissioningarmFailSafeInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) @@ -5672,7 +5672,7 @@ public Map> getCommandMap() { commandArguments.get("breadcrumb") , (Long) commandArguments.get("timeoutMs") - + ); }, () -> new DelegatedArmFailSafeResponseCallback(), @@ -5684,7 +5684,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) .commissioningComplete((ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback) callback - + ); }, () -> new DelegatedCommissioningCompleteResponseCallback(), @@ -5694,16 +5694,16 @@ public Map> getCommandMap() { Map generalCommissioningsetRegulatoryConfigCommandParams = new LinkedHashMap(); CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = new CommandParameterInfo("location", Integer.class); generalCommissioningsetRegulatoryConfigCommandParams.put("location",generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); - + CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = new CommandParameterInfo("countryCode", String.class); generalCommissioningsetRegulatoryConfigCommandParams.put("countryCode",generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); - + CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); generalCommissioningsetRegulatoryConfigCommandParams.put("breadcrumb",generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); - + CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); generalCommissioningsetRegulatoryConfigCommandParams.put("timeoutMs",generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); - + InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GeneralCommissioningCluster) cluster) @@ -5716,7 +5716,7 @@ public Map> getCommandMap() { commandArguments.get("breadcrumb") , (Long) commandArguments.get("timeoutMs") - + ); }, () -> new DelegatedSetRegulatoryConfigResponseCallback(), @@ -5730,14 +5730,14 @@ public Map> getCommandMap() { Map groupKeyManagementkeySetReadCommandParams = new LinkedHashMap(); CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); groupKeyManagementkeySetReadCommandParams.put("groupKeySetID",groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); - + InteractionInfo groupKeyManagementkeySetReadInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .keySetRead((ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback , (Integer) commandArguments.get("groupKeySetID") - + ); }, () -> new DelegatedKeySetReadResponseCallback(), @@ -5747,14 +5747,14 @@ public Map> getCommandMap() { Map groupKeyManagementkeySetReadAllIndicesCommandParams = new LinkedHashMap(); CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = new CommandParameterInfo("groupKeySetIDs", ArrayList.class); groupKeyManagementkeySetReadAllIndicesCommandParams.put("groupKeySetIDs",groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); - + InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .keySetReadAllIndices((ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) callback , (ArrayList) commandArguments.get("groupKeySetIDs") - + ); }, () -> new DelegatedKeySetReadAllIndicesResponseCallback(), @@ -5764,14 +5764,14 @@ public Map> getCommandMap() { Map groupKeyManagementkeySetRemoveCommandParams = new LinkedHashMap(); CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); groupKeyManagementkeySetRemoveCommandParams.put("groupKeySetID",groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); - + InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupKeyManagementCluster) cluster) .keySetRemove((DefaultClusterCallback) callback , (Integer) commandArguments.get("groupKeySetID") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5785,7 +5785,7 @@ public Map> getCommandMap() { .keySetWrite((DefaultClusterCallback) callback , (ChipStructs.GroupKeyManagementClusterGroupKeySet) commandArguments.get("groupKeySet") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5797,10 +5797,10 @@ public Map> getCommandMap() { Map groupsaddGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsaddGroupCommandParams.put("groupId",groupsaddGroupgroupIdCommandParameterInfo); - + CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); groupsaddGroupCommandParams.put("groupName",groupsaddGroupgroupNameCommandParameterInfo); - + InteractionInfo groupsaddGroupInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) @@ -5809,7 +5809,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (String) commandArguments.get("groupName") - + ); }, () -> new DelegatedAddGroupResponseCallback(), @@ -5819,10 +5819,10 @@ public Map> getCommandMap() { Map groupsaddGroupIfIdentifyingCommandParams = new LinkedHashMap(); CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsaddGroupIfIdentifyingCommandParams.put("groupId",groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); - + CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); groupsaddGroupIfIdentifyingCommandParams.put("groupName",groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); - + InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) @@ -5831,7 +5831,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (String) commandArguments.get("groupName") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5841,14 +5841,14 @@ public Map> getCommandMap() { Map groupsgetGroupMembershipCommandParams = new LinkedHashMap(); CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = new CommandParameterInfo("groupList", ArrayList.class); groupsgetGroupMembershipCommandParams.put("groupList",groupsgetGroupMembershipgroupListCommandParameterInfo); - + InteractionInfo groupsgetGroupMembershipInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .getGroupMembership((ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback , (ArrayList) commandArguments.get("groupList") - + ); }, () -> new DelegatedGetGroupMembershipResponseCallback(), @@ -5860,7 +5860,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .removeAllGroups((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5870,14 +5870,14 @@ public Map> getCommandMap() { Map groupsremoveGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsremoveGroupCommandParams.put("groupId",groupsremoveGroupgroupIdCommandParameterInfo); - + InteractionInfo groupsremoveGroupInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .removeGroup((ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedRemoveGroupResponseCallback(), @@ -5887,14 +5887,14 @@ public Map> getCommandMap() { Map groupsviewGroupCommandParams = new LinkedHashMap(); CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); groupsviewGroupCommandParams.put("groupId",groupsviewGroupgroupIdCommandParameterInfo); - + InteractionInfo groupsviewGroupInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.GroupsCluster) cluster) .viewGroup((ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedViewGroupResponseCallback(), @@ -5906,14 +5906,14 @@ public Map> getCommandMap() { Map identifyidentifyCommandParams = new LinkedHashMap(); CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("identifyTime", Integer.class); identifyidentifyCommandParams.put("identifyTime",identifyidentifyidentifyTimeCommandParameterInfo); - + InteractionInfo identifyidentifyInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .identify((DefaultClusterCallback) callback , (Integer) commandArguments.get("identifyTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5925,7 +5925,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) .identifyQuery((ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback - + ); }, () -> new DelegatedIdentifyQueryResponseCallback(), @@ -5935,10 +5935,10 @@ public Map> getCommandMap() { Map identifytriggerEffectCommandParams = new LinkedHashMap(); CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = new CommandParameterInfo("effectIdentifier", Integer.class); identifytriggerEffectCommandParams.put("effectIdentifier",identifytriggerEffecteffectIdentifierCommandParameterInfo); - + CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); identifytriggerEffectCommandParams.put("effectVariant",identifytriggerEffecteffectVariantCommandParameterInfo); - + InteractionInfo identifytriggerEffectInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.IdentifyCluster) cluster) @@ -5947,7 +5947,7 @@ public Map> getCommandMap() { commandArguments.get("effectIdentifier") , (Integer) commandArguments.get("effectVariant") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -5961,14 +5961,14 @@ public Map> getCommandMap() { Map keypadInputsendKeyRequestCommandParams = new LinkedHashMap(); CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = new CommandParameterInfo("keyCode", Integer.class); keypadInputsendKeyRequestCommandParams.put("keyCode",keypadInputsendKeyRequestkeyCodeCommandParameterInfo); - + InteractionInfo keypadInputsendKeyRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.KeypadInputCluster) cluster) .sendKeyRequest((ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback , (Integer) commandArguments.get("keyCode") - + ); }, () -> new DelegatedSendKeyResponseCallback(), @@ -5980,16 +5980,16 @@ public Map> getCommandMap() { Map levelControlmoveCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); levelControlmoveCommandParams.put("moveMode",levelControlmovemoveModeCommandParameterInfo); - + CommandParameterInfo levelControlmoverateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); levelControlmoveCommandParams.put("rate",levelControlmoverateCommandParameterInfo); - + CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlmoveCommandParams.put("optionMask",levelControlmoveoptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlmoveCommandParams.put("optionOverride",levelControlmoveoptionOverrideCommandParameterInfo); - + InteractionInfo levelControlmoveInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6002,7 +6002,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6012,16 +6012,16 @@ public Map> getCommandMap() { Map levelControlmoveToLevelCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); levelControlmoveToLevelCommandParams.put("level",levelControlmoveToLevellevelCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlmoveToLevelCommandParams.put("transitionTime",levelControlmoveToLeveltransitionTimeCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlmoveToLevelCommandParams.put("optionMask",levelControlmoveToLeveloptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlmoveToLevelCommandParams.put("optionOverride",levelControlmoveToLeveloptionOverrideCommandParameterInfo); - + InteractionInfo levelControlmoveToLevelInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6034,7 +6034,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6044,10 +6044,10 @@ public Map> getCommandMap() { Map levelControlmoveToLevelWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); levelControlmoveToLevelWithOnOffCommandParams.put("level",levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); - + CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlmoveToLevelWithOnOffCommandParams.put("transitionTime",levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); - + InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6056,7 +6056,7 @@ public Map> getCommandMap() { commandArguments.get("level") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6066,10 +6066,10 @@ public Map> getCommandMap() { Map levelControlmoveWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); levelControlmoveWithOnOffCommandParams.put("moveMode",levelControlmoveWithOnOffmoveModeCommandParameterInfo); - + CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); levelControlmoveWithOnOffCommandParams.put("rate",levelControlmoveWithOnOffrateCommandParameterInfo); - + InteractionInfo levelControlmoveWithOnOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6078,7 +6078,7 @@ public Map> getCommandMap() { commandArguments.get("moveMode") , (Integer) commandArguments.get("rate") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6088,19 +6088,19 @@ public Map> getCommandMap() { Map levelControlstepCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstepstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); levelControlstepCommandParams.put("stepMode",levelControlstepstepModeCommandParameterInfo); - + CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); levelControlstepCommandParams.put("stepSize",levelControlstepstepSizeCommandParameterInfo); - + CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlstepCommandParams.put("transitionTime",levelControlsteptransitionTimeCommandParameterInfo); - + CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlstepCommandParams.put("optionMask",levelControlstepoptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlstepCommandParams.put("optionOverride",levelControlstepoptionOverrideCommandParameterInfo); - + InteractionInfo levelControlstepInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6115,7 +6115,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6125,13 +6125,13 @@ public Map> getCommandMap() { Map levelControlstepWithOnOffCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); levelControlstepWithOnOffCommandParams.put("stepMode",levelControlstepWithOnOffstepModeCommandParameterInfo); - + CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); levelControlstepWithOnOffCommandParams.put("stepSize",levelControlstepWithOnOffstepSizeCommandParameterInfo); - + CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); levelControlstepWithOnOffCommandParams.put("transitionTime",levelControlstepWithOnOfftransitionTimeCommandParameterInfo); - + InteractionInfo levelControlstepWithOnOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6142,7 +6142,7 @@ public Map> getCommandMap() { commandArguments.get("stepSize") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6152,10 +6152,10 @@ public Map> getCommandMap() { Map levelControlstopCommandParams = new LinkedHashMap(); CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); levelControlstopCommandParams.put("optionMask",levelControlstopoptionMaskCommandParameterInfo); - + CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); levelControlstopCommandParams.put("optionOverride",levelControlstopoptionOverrideCommandParameterInfo); - + InteractionInfo levelControlstopInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) @@ -6164,7 +6164,7 @@ public Map> getCommandMap() { commandArguments.get("optionMask") , (Integer) commandArguments.get("optionOverride") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6176,7 +6176,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.LevelControlCluster) cluster) .stopWithOnOff((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6192,7 +6192,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.LowPowerCluster) cluster) .sleep((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6206,7 +6206,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .hideInputStatusRequest((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6216,10 +6216,10 @@ public Map> getCommandMap() { Map mediaInputrenameInputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); mediaInputrenameInputRequestCommandParams.put("index",mediaInputrenameInputRequestindexCommandParameterInfo); - + CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); mediaInputrenameInputRequestCommandParams.put("name",mediaInputrenameInputRequestnameCommandParameterInfo); - + InteractionInfo mediaInputrenameInputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) @@ -6228,7 +6228,7 @@ public Map> getCommandMap() { commandArguments.get("index") , (String) commandArguments.get("name") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6238,14 +6238,14 @@ public Map> getCommandMap() { Map mediaInputselectInputRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); mediaInputselectInputRequestCommandParams.put("index",mediaInputselectInputRequestindexCommandParameterInfo); - + InteractionInfo mediaInputselectInputRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .selectInputRequest((DefaultClusterCallback) callback , (Integer) commandArguments.get("index") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6257,7 +6257,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaInputCluster) cluster) .showInputStatusRequest((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6271,7 +6271,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .fastForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6283,7 +6283,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .nextRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6295,7 +6295,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .pauseRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6307,7 +6307,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .playRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6319,7 +6319,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .previousRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6331,7 +6331,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .rewindRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6341,14 +6341,14 @@ public Map> getCommandMap() { Map mediaPlaybackseekRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = new CommandParameterInfo("position", Long.class); mediaPlaybackseekRequestCommandParams.put("position",mediaPlaybackseekRequestpositionCommandParameterInfo); - + InteractionInfo mediaPlaybackseekRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .seekRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback , (Long) commandArguments.get("position") - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6358,14 +6358,14 @@ public Map> getCommandMap() { Map mediaPlaybackskipBackwardRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); mediaPlaybackskipBackwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); - + InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .skipBackwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback , (Long) commandArguments.get("deltaPositionMilliseconds") - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6375,14 +6375,14 @@ public Map> getCommandMap() { Map mediaPlaybackskipForwardRequestCommandParams = new LinkedHashMap(); CommandParameterInfo mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); mediaPlaybackskipForwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); - + InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .skipForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback , (Long) commandArguments.get("deltaPositionMilliseconds") - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6394,7 +6394,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .startOverRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6406,7 +6406,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.MediaPlaybackCluster) cluster) .stopRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - + ); }, () -> new DelegatedPlaybackResponseCallback(), @@ -6418,14 +6418,14 @@ public Map> getCommandMap() { Map modeSelectchangeToModeCommandParams = new LinkedHashMap(); CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = new CommandParameterInfo("newMode", Integer.class); modeSelectchangeToModeCommandParams.put("newMode",modeSelectchangeToModenewModeCommandParameterInfo); - + InteractionInfo modeSelectchangeToModeInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ModeSelectCluster) cluster) .changeToMode((DefaultClusterCallback) callback , (Integer) commandArguments.get("newMode") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6437,10 +6437,10 @@ public Map> getCommandMap() { Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = new CommandParameterInfo("operationalDataset", byte[].class); networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("operationalDataset",networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); - + CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6449,7 +6449,7 @@ public Map> getCommandMap() { commandArguments.get("operationalDataset") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6459,13 +6459,13 @@ public Map> getCommandMap() { Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("ssid",networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); - + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = new CommandParameterInfo("credentials", byte[].class); networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("credentials",networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); - + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6476,7 +6476,7 @@ public Map> getCommandMap() { commandArguments.get("credentials") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6486,10 +6486,10 @@ public Map> getCommandMap() { Map networkCommissioningconnectNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); networkCommissioningconnectNetworkCommandParams.put("networkID",networkCommissioningconnectNetworknetworkIDCommandParameterInfo); - + CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningconnectNetworkCommandParams.put("breadcrumb",networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningconnectNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6498,7 +6498,7 @@ public Map> getCommandMap() { commandArguments.get("networkID") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedConnectNetworkResponseCallback(), @@ -6508,10 +6508,10 @@ public Map> getCommandMap() { Map networkCommissioningremoveNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); networkCommissioningremoveNetworkCommandParams.put("networkID",networkCommissioningremoveNetworknetworkIDCommandParameterInfo); - + CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningremoveNetworkCommandParams.put("breadcrumb",networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningremoveNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6520,7 +6520,7 @@ public Map> getCommandMap() { commandArguments.get("networkID") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6530,13 +6530,13 @@ public Map> getCommandMap() { Map networkCommissioningreorderNetworkCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); networkCommissioningreorderNetworkCommandParams.put("networkID",networkCommissioningreorderNetworknetworkIDCommandParameterInfo); - + CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = new CommandParameterInfo("networkIndex", Integer.class); networkCommissioningreorderNetworkCommandParams.put("networkIndex",networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); - + CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningreorderNetworkCommandParams.put("breadcrumb",networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningreorderNetworkInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6547,7 +6547,7 @@ public Map> getCommandMap() { commandArguments.get("networkIndex") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedNetworkConfigResponseCallback(), @@ -6557,10 +6557,10 @@ public Map> getCommandMap() { Map networkCommissioningscanNetworksCommandParams = new LinkedHashMap(); CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); networkCommissioningscanNetworksCommandParams.put("ssid",networkCommissioningscanNetworksssidCommandParameterInfo); - + CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); networkCommissioningscanNetworksCommandParams.put("breadcrumb",networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); - + InteractionInfo networkCommissioningscanNetworksInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.NetworkCommissioningCluster) cluster) @@ -6569,7 +6569,7 @@ public Map> getCommandMap() { commandArguments.get("ssid") , (Long) commandArguments.get("breadcrumb") - + ); }, () -> new DelegatedScanNetworksResponseCallback(), @@ -6581,10 +6581,10 @@ public Map> getCommandMap() { Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("updateToken",otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = new CommandParameterInfo("newVersion", Long.class); otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("newVersion",otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) @@ -6593,7 +6593,7 @@ public Map> getCommandMap() { commandArguments.get("updateToken") , (Long) commandArguments.get("newVersion") - + ); }, () -> new DelegatedApplyUpdateResponseCallback(), @@ -6603,10 +6603,10 @@ public Map> getCommandMap() { Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("updateToken",otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("softwareVersion",otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) @@ -6615,7 +6615,7 @@ public Map> getCommandMap() { commandArguments.get("updateToken") , (Long) commandArguments.get("softwareVersion") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6625,28 +6625,28 @@ public Map> getCommandMap() { Map otaSoftwareUpdateProviderqueryImageCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("vendorId",otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = new CommandParameterInfo("productId", Integer.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("productId",otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("softwareVersion",otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = new CommandParameterInfo("protocolsSupported", ArrayList.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("protocolsSupported",otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = new CommandParameterInfo("hardwareVersion", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("hardwareVersion",otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = new CommandParameterInfo("location", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("location",otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = new CommandParameterInfo("requestorCanConsent", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("requestorCanConsent",otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = new CommandParameterInfo("metadataForProvider", Optional.class); otaSoftwareUpdateProviderqueryImageCommandParams.put("metadataForProvider",otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) @@ -6667,7 +6667,7 @@ public Map> getCommandMap() { commandArguments.get("requestorCanConsent") , (Optional) commandArguments.get("metadataForProvider") - + ); }, () -> new DelegatedQueryImageResponseCallback(), @@ -6679,19 +6679,19 @@ public Map> getCommandMap() { Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = new LinkedHashMap(); CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = new CommandParameterInfo("providerNodeId", Long.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("providerNodeId",otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("vendorId",otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = new CommandParameterInfo("announcementReason", Integer.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("announcementReason",otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = new CommandParameterInfo("metadataForNode", Optional.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("metadataForNode",otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); - + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = new CommandParameterInfo("endpoint", Integer.class); otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("endpoint",otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); - + InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) @@ -6706,7 +6706,7 @@ public Map> getCommandMap() { commandArguments.get("metadataForNode") , (Integer) commandArguments.get("endpoint") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6722,7 +6722,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .off((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6732,10 +6732,10 @@ public Map> getCommandMap() { Map onOffoffWithEffectCommandParams = new LinkedHashMap(); CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = new CommandParameterInfo("effectId", Integer.class); onOffoffWithEffectCommandParams.put("effectId",onOffoffWithEffecteffectIdCommandParameterInfo); - + CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); onOffoffWithEffectCommandParams.put("effectVariant",onOffoffWithEffecteffectVariantCommandParameterInfo); - + InteractionInfo onOffoffWithEffectInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) @@ -6744,7 +6744,7 @@ public Map> getCommandMap() { commandArguments.get("effectId") , (Integer) commandArguments.get("effectVariant") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6756,7 +6756,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .on((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6768,7 +6768,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .onWithRecallGlobalScene((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6778,13 +6778,13 @@ public Map> getCommandMap() { Map onOffonWithTimedOffCommandParams = new LinkedHashMap(); CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = new CommandParameterInfo("onOffControl", Integer.class); onOffonWithTimedOffCommandParams.put("onOffControl",onOffonWithTimedOffonOffControlCommandParameterInfo); - + CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = new CommandParameterInfo("onTime", Integer.class); onOffonWithTimedOffCommandParams.put("onTime",onOffonWithTimedOffonTimeCommandParameterInfo); - + CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("offWaitTime", Integer.class); onOffonWithTimedOffCommandParams.put("offWaitTime",onOffonWithTimedOffoffWaitTimeCommandParameterInfo); - + InteractionInfo onOffonWithTimedOffInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) @@ -6795,7 +6795,7 @@ public Map> getCommandMap() { commandArguments.get("onTime") , (Integer) commandArguments.get("offWaitTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6807,7 +6807,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.OnOffCluster) cluster) .toggle((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6821,19 +6821,19 @@ public Map> getCommandMap() { Map operationalCredentialsaddNOCCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); operationalCredentialsaddNOCCommandParams.put("NOCValue",operationalCredentialsaddNOCNOCValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); operationalCredentialsaddNOCCommandParams.put("ICACValue",operationalCredentialsaddNOCICACValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = new CommandParameterInfo("IPKValue", byte[].class); operationalCredentialsaddNOCCommandParams.put("IPKValue",operationalCredentialsaddNOCIPKValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = new CommandParameterInfo("caseAdminNode", Long.class); operationalCredentialsaddNOCCommandParams.put("caseAdminNode",operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); - + CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = new CommandParameterInfo("adminVendorId", Integer.class); operationalCredentialsaddNOCCommandParams.put("adminVendorId",operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); - + InteractionInfo operationalCredentialsaddNOCInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) @@ -6848,7 +6848,7 @@ public Map> getCommandMap() { commandArguments.get("caseAdminNode") , (Integer) commandArguments.get("adminVendorId") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -6858,14 +6858,14 @@ public Map> getCommandMap() { Map operationalCredentialsaddTrustedRootCertificateCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = new CommandParameterInfo("rootCertificate", byte[].class); operationalCredentialsaddTrustedRootCertificateCommandParams.put("rootCertificate",operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); - + InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .addTrustedRootCertificate((DefaultClusterCallback) callback , (byte[]) commandArguments.get("rootCertificate") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6875,14 +6875,14 @@ public Map> getCommandMap() { Map operationalCredentialsattestationRequestCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = new CommandParameterInfo("attestationNonce", byte[].class); operationalCredentialsattestationRequestCommandParams.put("attestationNonce",operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); - + InteractionInfo operationalCredentialsattestationRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .attestationRequest((ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) callback , (byte[]) commandArguments.get("attestationNonce") - + ); }, () -> new DelegatedAttestationResponseCallback(), @@ -6892,14 +6892,14 @@ public Map> getCommandMap() { Map operationalCredentialscertificateChainRequestCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = new CommandParameterInfo("certificateType", Integer.class); operationalCredentialscertificateChainRequestCommandParams.put("certificateType",operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); - + InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .certificateChainRequest((ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) callback , (Integer) commandArguments.get("certificateType") - + ); }, () -> new DelegatedCertificateChainResponseCallback(), @@ -6909,14 +6909,14 @@ public Map> getCommandMap() { Map operationalCredentialsopCSRRequestCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = new CommandParameterInfo("CSRNonce", byte[].class); operationalCredentialsopCSRRequestCommandParams.put("CSRNonce",operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); - + InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .opCSRRequest((ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback , (byte[]) commandArguments.get("CSRNonce") - + ); }, () -> new DelegatedOpCSRResponseCallback(), @@ -6926,14 +6926,14 @@ public Map> getCommandMap() { Map operationalCredentialsremoveFabricCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = new CommandParameterInfo("fabricIndex", Integer.class); operationalCredentialsremoveFabricCommandParams.put("fabricIndex",operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); - + InteractionInfo operationalCredentialsremoveFabricInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .removeFabric((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback , (Integer) commandArguments.get("fabricIndex") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -6943,14 +6943,14 @@ public Map> getCommandMap() { Map operationalCredentialsremoveTrustedRootCertificateCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = new CommandParameterInfo("trustedRootIdentifier", byte[].class); operationalCredentialsremoveTrustedRootCertificateCommandParams.put("trustedRootIdentifier",operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); - + InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .removeTrustedRootCertificate((DefaultClusterCallback) callback , (byte[]) commandArguments.get("trustedRootIdentifier") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -6960,14 +6960,14 @@ public Map> getCommandMap() { Map operationalCredentialsupdateFabricLabelCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = new CommandParameterInfo("label", String.class); operationalCredentialsupdateFabricLabelCommandParams.put("label",operationalCredentialsupdateFabricLabellabelCommandParameterInfo); - + InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) .updateFabricLabel((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback , (String) commandArguments.get("label") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -6977,10 +6977,10 @@ public Map> getCommandMap() { Map operationalCredentialsupdateNOCCommandParams = new LinkedHashMap(); CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); operationalCredentialsupdateNOCCommandParams.put("NOCValue",operationalCredentialsupdateNOCNOCValueCommandParameterInfo); - + CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); operationalCredentialsupdateNOCCommandParams.put("ICACValue",operationalCredentialsupdateNOCICACValueCommandParameterInfo); - + InteractionInfo operationalCredentialsupdateNOCInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.OperationalCredentialsCluster) cluster) @@ -6989,7 +6989,7 @@ public Map> getCommandMap() { commandArguments.get("NOCValue") , (Optional) commandArguments.get("ICACValue") - + ); }, () -> new DelegatedNOCResponseCallback(), @@ -7011,16 +7011,16 @@ public Map> getCommandMap() { Map scenesaddSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesaddSceneCommandParams.put("groupId",scenesaddScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesaddSceneCommandParams.put("sceneId",scenesaddScenesceneIdCommandParameterInfo); - + CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); scenesaddSceneCommandParams.put("transitionTime",scenesaddScenetransitionTimeCommandParameterInfo); - + CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = new CommandParameterInfo("sceneName", String.class); scenesaddSceneCommandParams.put("sceneName",scenesaddScenesceneNameCommandParameterInfo); - + InteractionInfo scenesaddSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7035,7 +7035,7 @@ public Map> getCommandMap() { commandArguments.get("sceneName") , (ArrayList) commandArguments.get("extensionFieldSets") - + ); }, () -> new DelegatedAddSceneResponseCallback(), @@ -7045,14 +7045,14 @@ public Map> getCommandMap() { Map scenesgetSceneMembershipCommandParams = new LinkedHashMap(); CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesgetSceneMembershipCommandParams.put("groupId",scenesgetSceneMembershipgroupIdCommandParameterInfo); - + InteractionInfo scenesgetSceneMembershipInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .getSceneMembership((ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedGetSceneMembershipResponseCallback(), @@ -7062,13 +7062,13 @@ public Map> getCommandMap() { Map scenesrecallSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesrecallSceneCommandParams.put("groupId",scenesrecallScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesrecallSceneCommandParams.put("sceneId",scenesrecallScenesceneIdCommandParameterInfo); - + CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); scenesrecallSceneCommandParams.put("transitionTime",scenesrecallScenetransitionTimeCommandParameterInfo); - + InteractionInfo scenesrecallSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7079,7 +7079,7 @@ public Map> getCommandMap() { commandArguments.get("sceneId") , (Integer) commandArguments.get("transitionTime") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7089,14 +7089,14 @@ public Map> getCommandMap() { Map scenesremoveAllScenesCommandParams = new LinkedHashMap(); CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesremoveAllScenesCommandParams.put("groupId",scenesremoveAllScenesgroupIdCommandParameterInfo); - + InteractionInfo scenesremoveAllScenesInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) .removeAllScenes((ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback , (Integer) commandArguments.get("groupId") - + ); }, () -> new DelegatedRemoveAllScenesResponseCallback(), @@ -7106,10 +7106,10 @@ public Map> getCommandMap() { Map scenesremoveSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesremoveSceneCommandParams.put("groupId",scenesremoveScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesremoveSceneCommandParams.put("sceneId",scenesremoveScenesceneIdCommandParameterInfo); - + InteractionInfo scenesremoveSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7118,7 +7118,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (Integer) commandArguments.get("sceneId") - + ); }, () -> new DelegatedRemoveSceneResponseCallback(), @@ -7128,10 +7128,10 @@ public Map> getCommandMap() { Map scenesstoreSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesstoreSceneCommandParams.put("groupId",scenesstoreScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesstoreSceneCommandParams.put("sceneId",scenesstoreScenesceneIdCommandParameterInfo); - + InteractionInfo scenesstoreSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7140,7 +7140,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (Integer) commandArguments.get("sceneId") - + ); }, () -> new DelegatedStoreSceneResponseCallback(), @@ -7150,10 +7150,10 @@ public Map> getCommandMap() { Map scenesviewSceneCommandParams = new LinkedHashMap(); CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); scenesviewSceneCommandParams.put("groupId",scenesviewScenegroupIdCommandParameterInfo); - + CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); scenesviewSceneCommandParams.put("sceneId",scenesviewScenesceneIdCommandParameterInfo); - + InteractionInfo scenesviewSceneInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ScenesCluster) cluster) @@ -7162,7 +7162,7 @@ public Map> getCommandMap() { commandArguments.get("groupId") , (Integer) commandArguments.get("sceneId") - + ); }, () -> new DelegatedViewSceneResponseCallback(), @@ -7176,7 +7176,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.SoftwareDiagnosticsCluster) cluster) .resetWatermarks((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7190,10 +7190,10 @@ public Map> getCommandMap() { Map targetNavigatornavigateTargetRequestCommandParams = new LinkedHashMap(); CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = new CommandParameterInfo("target", Integer.class); targetNavigatornavigateTargetRequestCommandParams.put("target",targetNavigatornavigateTargetRequesttargetCommandParameterInfo); - + CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); targetNavigatornavigateTargetRequestCommandParams.put("data",targetNavigatornavigateTargetRequestdataCommandParameterInfo); - + InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TargetNavigatorCluster) cluster) @@ -7202,7 +7202,7 @@ public Map> getCommandMap() { commandArguments.get("target") , (String) commandArguments.get("data") - + ); }, () -> new DelegatedNavigateTargetResponseCallback(), @@ -7220,7 +7220,7 @@ public Map> getCommandMap() { .simpleStructEchoRequest((ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback , (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1") - + ); }, () -> new DelegatedSimpleStructResponseCallback(), @@ -7232,7 +7232,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .test((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7242,10 +7242,10 @@ public Map> getCommandMap() { Map testClustertestAddArgumentsCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); testClustertestAddArgumentsCommandParams.put("arg1",testClustertestAddArgumentsarg1CommandParameterInfo); - + CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); testClustertestAddArgumentsCommandParams.put("arg2",testClustertestAddArgumentsarg2CommandParameterInfo); - + InteractionInfo testClustertestAddArgumentsInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) @@ -7254,7 +7254,7 @@ public Map> getCommandMap() { commandArguments.get("arg1") , (Integer) commandArguments.get("arg2") - + ); }, () -> new DelegatedTestAddArgumentsResponseCallback(), @@ -7264,13 +7264,13 @@ public Map> getCommandMap() { Map testClustertestEmitTestEventRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); testClustertestEmitTestEventRequestCommandParams.put("arg1",testClustertestEmitTestEventRequestarg1CommandParameterInfo); - + CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); testClustertestEmitTestEventRequestCommandParams.put("arg2",testClustertestEmitTestEventRequestarg2CommandParameterInfo); - + CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = new CommandParameterInfo("arg3", Boolean.class); testClustertestEmitTestEventRequestCommandParams.put("arg3",testClustertestEmitTestEventRequestarg3CommandParameterInfo); - + InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) @@ -7281,7 +7281,7 @@ public Map> getCommandMap() { commandArguments.get("arg2") , (Boolean) commandArguments.get("arg3") - + ); }, () -> new DelegatedTestEmitTestEventResponseCallback(), @@ -7291,10 +7291,10 @@ public Map> getCommandMap() { Map testClustertestEnumsRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); testClustertestEnumsRequestCommandParams.put("arg1",testClustertestEnumsRequestarg1CommandParameterInfo); - + CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); testClustertestEnumsRequestCommandParams.put("arg2",testClustertestEnumsRequestarg2CommandParameterInfo); - + InteractionInfo testClustertestEnumsRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) @@ -7303,7 +7303,7 @@ public Map> getCommandMap() { commandArguments.get("arg1") , (Integer) commandArguments.get("arg2") - + ); }, () -> new DelegatedTestEnumsResponseCallback(), @@ -7313,14 +7313,14 @@ public Map> getCommandMap() { Map testClustertestListInt8UArgumentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); testClustertestListInt8UArgumentRequestCommandParams.put("arg1",testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testListInt8UArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7330,14 +7330,14 @@ public Map> getCommandMap() { Map testClustertestListInt8UReverseRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); testClustertestListInt8UReverseRequestCommandParams.put("arg1",testClustertestListInt8UReverseRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testListInt8UReverseRequest((ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedTestListInt8UReverseResponseCallback(), @@ -7351,7 +7351,7 @@ public Map> getCommandMap() { .testListNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7365,7 +7365,7 @@ public Map> getCommandMap() { .testListStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ArrayList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7379,7 +7379,7 @@ public Map> getCommandMap() { .testNestedStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ChipStructs.TestClusterClusterNestedStruct) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7393,7 +7393,7 @@ public Map> getCommandMap() { .testNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ChipStructs.TestClusterClusterNestedStructList) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7405,7 +7405,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testNotHandled((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7415,14 +7415,14 @@ public Map> getCommandMap() { Map testClustertestNullableOptionalRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); testClustertestNullableOptionalRequestCommandParams.put("arg1",testClustertestNullableOptionalRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testNullableOptionalRequest((ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) callback , (Optional) commandArguments.get("arg1") - + ); }, () -> new DelegatedTestNullableOptionalResponseCallback(), @@ -7432,14 +7432,14 @@ public Map> getCommandMap() { Map testClustertestSimpleOptionalArgumentRequestCommandParams = new LinkedHashMap(); CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); testClustertestSimpleOptionalArgumentRequestCommandParams.put("arg1",testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); - + InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testSimpleOptionalArgumentRequest((DefaultClusterCallback) callback , (Optional) commandArguments.get("arg1") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7451,7 +7451,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testSpecific((ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback - + ); }, () -> new DelegatedTestSpecificResponseCallback(), @@ -7465,7 +7465,7 @@ public Map> getCommandMap() { .testStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback , (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1") - + ); }, () -> new DelegatedBooleanResponseCallback(), @@ -7477,7 +7477,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.TestClusterCluster) cluster) .testUnknownCommand((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7503,7 +7503,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .clearWeeklySchedule((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7515,7 +7515,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) .getRelayStatusLog((ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback - + ); }, () -> new DelegatedGetRelayStatusLogResponseCallback(), @@ -7525,10 +7525,10 @@ public Map> getCommandMap() { Map thermostatgetWeeklyScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = new CommandParameterInfo("daysToReturn", Integer.class); thermostatgetWeeklyScheduleCommandParams.put("daysToReturn",thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); - + CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = new CommandParameterInfo("modeToReturn", Integer.class); thermostatgetWeeklyScheduleCommandParams.put("modeToReturn",thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); - + InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) @@ -7537,7 +7537,7 @@ public Map> getCommandMap() { commandArguments.get("daysToReturn") , (Integer) commandArguments.get("modeToReturn") - + ); }, () -> new DelegatedGetWeeklyScheduleResponseCallback(), @@ -7547,16 +7547,16 @@ public Map> getCommandMap() { Map thermostatsetWeeklyScheduleCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); thermostatsetWeeklyScheduleCommandParams.put("numberOfTransitionsForSequence",thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); - + CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = new CommandParameterInfo("dayOfWeekForSequence", Integer.class); thermostatsetWeeklyScheduleCommandParams.put("dayOfWeekForSequence",thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); - + CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = new CommandParameterInfo("modeForSequence", Integer.class); thermostatsetWeeklyScheduleCommandParams.put("modeForSequence",thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); - + CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = new CommandParameterInfo("payload", ArrayList.class); thermostatsetWeeklyScheduleCommandParams.put("payload",thermostatsetWeeklySchedulepayloadCommandParameterInfo); - + InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) @@ -7569,7 +7569,7 @@ public Map> getCommandMap() { commandArguments.get("modeForSequence") , (ArrayList) commandArguments.get("payload") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7579,10 +7579,10 @@ public Map> getCommandMap() { Map thermostatsetpointRaiseLowerCommandParams = new LinkedHashMap(); CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = new CommandParameterInfo("mode", Integer.class); thermostatsetpointRaiseLowerCommandParams.put("mode",thermostatsetpointRaiseLowermodeCommandParameterInfo); - + CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = new CommandParameterInfo("amount", Integer.class); thermostatsetpointRaiseLowerCommandParams.put("amount",thermostatsetpointRaiseLoweramountCommandParameterInfo); - + InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.ThermostatCluster) cluster) @@ -7591,7 +7591,7 @@ public Map> getCommandMap() { commandArguments.get("mode") , (Integer) commandArguments.get("amount") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7607,7 +7607,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) .resetCounts((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7629,7 +7629,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) .resetCounts((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7643,7 +7643,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .downOrClose((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7653,10 +7653,10 @@ public Map> getCommandMap() { Map windowCoveringgoToLiftPercentageCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = new CommandParameterInfo("liftPercentageValue", Integer.class); windowCoveringgoToLiftPercentageCommandParams.put("liftPercentageValue",windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); - + CommandParameterInfo windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = new CommandParameterInfo("liftPercent100thsValue", Integer.class); windowCoveringgoToLiftPercentageCommandParams.put("liftPercent100thsValue",windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) @@ -7665,7 +7665,7 @@ public Map> getCommandMap() { commandArguments.get("liftPercentageValue") , (Integer) commandArguments.get("liftPercent100thsValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7675,14 +7675,14 @@ public Map> getCommandMap() { Map windowCoveringgoToLiftValueCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = new CommandParameterInfo("liftValue", Integer.class); windowCoveringgoToLiftValueCommandParams.put("liftValue",windowCoveringgoToLiftValueliftValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToLiftValueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .goToLiftValue((DefaultClusterCallback) callback , (Integer) commandArguments.get("liftValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7692,10 +7692,10 @@ public Map> getCommandMap() { Map windowCoveringgoToTiltPercentageCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = new CommandParameterInfo("tiltPercentageValue", Integer.class); windowCoveringgoToTiltPercentageCommandParams.put("tiltPercentageValue",windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); - + CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = new CommandParameterInfo("tiltPercent100thsValue", Integer.class); windowCoveringgoToTiltPercentageCommandParams.put("tiltPercent100thsValue",windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) @@ -7704,7 +7704,7 @@ public Map> getCommandMap() { commandArguments.get("tiltPercentageValue") , (Integer) commandArguments.get("tiltPercent100thsValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7714,14 +7714,14 @@ public Map> getCommandMap() { Map windowCoveringgoToTiltValueCommandParams = new LinkedHashMap(); CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = new CommandParameterInfo("tiltValue", Integer.class); windowCoveringgoToTiltValueCommandParams.put("tiltValue",windowCoveringgoToTiltValuetiltValueCommandParameterInfo); - + InteractionInfo windowCoveringgoToTiltValueInteractionInfo = new InteractionInfo( (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .goToTiltValue((DefaultClusterCallback) callback , (Integer) commandArguments.get("tiltValue") - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7733,7 +7733,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .stopMotion((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7745,7 +7745,7 @@ public Map> getCommandMap() { (cluster, callback, commandArguments) -> { ((ChipClusters.WindowCoveringCluster) cluster) .upOrOpen((DefaultClusterCallback) callback - + ); }, () -> new DelegatedDefaultClusterCallback(), @@ -7757,4 +7757,3 @@ public Map> getCommandMap() { } } - diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java index 48ec9330a3b2f2..e433d2ce7db37d 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java @@ -8070,4 +8070,3 @@ public Map> getReadAttributeMap() { return readAttributeMap; } } - diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java index a70c5b71a4a9de..e701c60d01ca31 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java @@ -53,7 +53,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -69,7 +69,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -85,7 +85,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -103,7 +103,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -119,7 +119,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -147,7 +147,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -163,7 +163,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -179,7 +179,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -195,7 +195,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -211,7 +211,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -227,7 +227,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -243,7 +243,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -259,7 +259,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -275,7 +275,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -291,7 +291,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -307,7 +307,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -323,7 +323,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -339,7 +339,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -357,7 +357,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -379,7 +379,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -395,7 +395,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -411,7 +411,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -427,7 +427,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -443,7 +443,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -459,7 +459,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -475,7 +475,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -501,7 +501,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -525,7 +525,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -547,7 +547,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -563,7 +563,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -579,7 +579,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -595,7 +595,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -611,7 +611,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -627,7 +627,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -643,7 +643,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -661,7 +661,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -685,7 +685,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -703,7 +703,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -727,7 +727,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -743,7 +743,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -759,7 +759,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -777,7 +777,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -803,7 +803,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -819,7 +819,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -835,7 +835,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -851,7 +851,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -881,7 +881,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -897,7 +897,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -913,7 +913,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -929,7 +929,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -945,7 +945,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -961,7 +961,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -977,7 +977,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -993,7 +993,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1009,7 +1009,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1025,7 +1025,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1041,7 +1041,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1057,7 +1057,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1073,7 +1073,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1089,7 +1089,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1105,7 +1105,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1121,7 +1121,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1137,7 +1137,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1153,7 +1153,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1169,7 +1169,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1185,7 +1185,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1201,7 +1201,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1217,7 +1217,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1233,7 +1233,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1249,7 +1249,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Float) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1265,7 +1265,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Double) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1281,7 +1281,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1297,7 +1297,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1313,7 +1313,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1329,7 +1329,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1345,7 +1345,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1361,7 +1361,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1377,7 +1377,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1393,7 +1393,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1409,7 +1409,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1425,7 +1425,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1441,7 +1441,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1457,7 +1457,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1489,7 +1489,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1505,7 +1505,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1521,7 +1521,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1537,7 +1537,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1553,7 +1553,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1569,7 +1569,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1585,7 +1585,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1601,7 +1601,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1617,7 +1617,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1633,7 +1633,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1649,7 +1649,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1665,7 +1665,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1681,7 +1681,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1697,7 +1697,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1713,7 +1713,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1729,7 +1729,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1745,7 +1745,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1761,7 +1761,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1777,7 +1777,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1793,7 +1793,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1809,7 +1809,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1825,7 +1825,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1841,7 +1841,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1857,7 +1857,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Long) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1873,7 +1873,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1889,7 +1889,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1905,7 +1905,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Float) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1921,7 +1921,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Double) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1937,7 +1937,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1953,7 +1953,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (String) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1969,7 +1969,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -1985,7 +1985,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2001,7 +2001,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2017,7 +2017,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2033,7 +2033,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2051,7 +2051,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2067,7 +2067,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2083,7 +2083,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2099,7 +2099,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2115,7 +2115,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2131,7 +2131,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2147,7 +2147,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2163,7 +2163,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2179,7 +2179,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2197,7 +2197,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2213,7 +2213,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2229,7 +2229,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2249,7 +2249,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2265,7 +2265,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2283,7 +2283,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2307,7 +2307,7 @@ public Map> getWriteAttributeMap() { (DefaultClusterCallback) callback, (Integer) commandArguments.get("value") - + ); }, () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), @@ -2318,4 +2318,3 @@ public Map> getWriteAttributeMap() { return writeAttributeMap; } } - From d6fc75f5eea0659eba6103b9fe7fac272d661d18 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Mon, 31 Jan 2022 22:25:29 +0000 Subject: [PATCH 14/14] Restyled by google-java-format --- .../chip/devicecontroller/ChipClusters.java | 23133 ++++++++-------- .../chip/devicecontroller/ChipStructs.java | 4075 ++- .../devicecontroller/ClusterInfoMapping.java | 16452 ++++++----- .../devicecontroller/ClusterReadMapping.java | 16098 +++++------ .../devicecontroller/ClusterWriteMapping.java | 4746 ++-- 5 files changed, 33661 insertions(+), 30843 deletions(-) diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index 84244edbcb62c1..5d633d4dab05af 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -21,7 +21,6 @@ import androidx.annotation.Nullable; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; import java.util.Optional; @@ -29,54 +28,69 @@ public class ChipClusters { public interface DefaultClusterCallback { void onSuccess(); + void onError(Exception error); } public interface CharStringAttributeCallback { /** Indicates a successful read for a CHAR_STRING attribute. */ void onSuccess(String value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface OctetStringAttributeCallback { /** Indicates a successful read for an OCTET_STRING attribute. */ void onSuccess(byte[] value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface IntegerAttributeCallback { void onSuccess(int value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface LongAttributeCallback { void onSuccess(long value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface BooleanAttributeCallback { void onSuccess(boolean value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface FloatAttributeCallback { void onSuccess(float value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } public interface DoubleAttributeCallback { void onSuccess(double value); + void onError(Exception error); + default void onSubscriptionEstablished() {} } - public static abstract class BaseChipCluster { + public abstract static class BaseChipCluster { protected long chipClusterPtr; public BaseChipCluster(long devicePtr, int endpointId) { @@ -108,115 +122,129 @@ public AccessControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AclAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ExtensionAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AclAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ExtensionAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAclAttribute( - AclAttributeCallback callback - ) { + public void readAclAttribute(AclAttributeCallback callback) { readAclAttribute(chipClusterPtr, callback); } - public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeAclAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeAclAttribute(chipClusterPtr, callback, value, null); } - public void writeAclAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeAclAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeAclAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeAclAttribute( - AclAttributeCallback callback - , - int minInterval, int maxInterval) { + AclAttributeCallback callback, int minInterval, int maxInterval) { subscribeAclAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readExtensionAttribute( - ExtensionAttributeCallback callback - ) { + public void readExtensionAttribute(ExtensionAttributeCallback callback) { readExtensionAttribute(chipClusterPtr, callback); } - public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeExtensionAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeExtensionAttribute(chipClusterPtr, callback, value, null); } - public void writeExtensionAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeExtensionAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeExtensionAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeExtensionAttribute( - ExtensionAttributeCallback callback - , - int minInterval, int maxInterval) { + ExtensionAttributeCallback callback, int minInterval, int maxInterval) { subscribeExtensionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAclAttribute(long chipClusterPtr, - AclAttributeCallback callback - ); - - private native void writeAclAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeAclAttribute(long chipClusterPtr, - AclAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readExtensionAttribute(long chipClusterPtr, - ExtensionAttributeCallback callback - ); - - private native void writeExtensionAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeExtensionAttribute(long chipClusterPtr, - ExtensionAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readAclAttribute(long chipClusterPtr, AclAttributeCallback callback); + + private native void writeAclAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeAclAttribute( + long chipClusterPtr, AclAttributeCallback callback, int minInterval, int maxInterval); + + private native void readExtensionAttribute( + long chipClusterPtr, ExtensionAttributeCallback callback); + + private native void writeExtensionAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeExtensionAttribute( + long chipClusterPtr, ExtensionAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class AccountLoginCluster extends BaseChipCluster { @@ -229,85 +257,90 @@ public AccountLoginCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - - public void getSetupPINRequest(GetSetupPINResponseCallback callback - , String tempAccountIdentifier - , int timedInvokeTimeoutMs) { + public void getSetupPINRequest( + GetSetupPINResponseCallback callback, + String tempAccountIdentifier, + int timedInvokeTimeoutMs) { getSetupPINRequest(chipClusterPtr, callback, tempAccountIdentifier, timedInvokeTimeoutMs); } - - public void loginRequest(DefaultClusterCallback callback - , String tempAccountIdentifier, String setupPIN - , int timedInvokeTimeoutMs) { + public void loginRequest( + DefaultClusterCallback callback, + String tempAccountIdentifier, + String setupPIN, + int timedInvokeTimeoutMs) { loginRequest(chipClusterPtr, callback, tempAccountIdentifier, setupPIN, timedInvokeTimeoutMs); } + public void logoutRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - public void logoutRequest(DefaultClusterCallback callback - - , int timedInvokeTimeoutMs) { logoutRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void getSetupPINRequest(long chipClusterPtr, GetSetupPINResponseCallback Callback - , String tempAccountIdentifier - , @Nullable Integer timedInvokeTimeoutMs); - private native void loginRequest(long chipClusterPtr, DefaultClusterCallback Callback - , String tempAccountIdentifier, String setupPIN - , @Nullable Integer timedInvokeTimeoutMs); - private native void logoutRequest(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void getSetupPINRequest( + long chipClusterPtr, + GetSetupPINResponseCallback Callback, + String tempAccountIdentifier, + @Nullable Integer timedInvokeTimeoutMs); + + private native void loginRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + String tempAccountIdentifier, + String setupPIN, + @Nullable Integer timedInvokeTimeoutMs); + + private native void logoutRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + public interface GetSetupPINResponseCallback { void onSuccess(String setupPIN); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 AdministratorCommissioningCluster extends BaseChipCluster { @@ -320,141 +353,156 @@ public AdministratorCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); + public void openBasicCommissioningWindow( + DefaultClusterCallback callback, Integer commissioningTimeout, int timedInvokeTimeoutMs) { + openBasicCommissioningWindow( + chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs); + } + + public void openCommissioningWindow( + DefaultClusterCallback callback, + Integer commissioningTimeout, + byte[] PAKEVerifier, + Integer discriminator, + Long iterations, + byte[] salt, + Integer passcodeID, + int timedInvokeTimeoutMs) { + openCommissioningWindow( + chipClusterPtr, + callback, + commissioningTimeout, + PAKEVerifier, + discriminator, + iterations, + salt, + passcodeID, + timedInvokeTimeoutMs); + } + + public void revokeCommissioning(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - public void openBasicCommissioningWindow(DefaultClusterCallback callback - , Integer commissioningTimeout - , int timedInvokeTimeoutMs) { - openBasicCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, timedInvokeTimeoutMs); + revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); } + private native void openBasicCommissioningWindow( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer commissioningTimeout, + @Nullable Integer timedInvokeTimeoutMs); - public void openCommissioningWindow(DefaultClusterCallback callback - , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID - , int timedInvokeTimeoutMs) { - openCommissioningWindow(chipClusterPtr, callback, commissioningTimeout, PAKEVerifier, discriminator, iterations, salt, passcodeID, timedInvokeTimeoutMs); - } + private native void openCommissioningWindow( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer commissioningTimeout, + byte[] PAKEVerifier, + Integer discriminator, + Long iterations, + byte[] salt, + Integer passcodeID, + @Nullable Integer timedInvokeTimeoutMs); + private native void revokeCommissioning( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public void revokeCommissioning(DefaultClusterCallback callback + public interface AdminFabricIndexAttributeCallback { + void onSuccess(Integer value); - , int timedInvokeTimeoutMs) { - revokeCommissioning(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void openBasicCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback - , Integer commissioningTimeout - , @Nullable Integer timedInvokeTimeoutMs); - private native void openCommissioningWindow(long chipClusterPtr, DefaultClusterCallback Callback - , Integer commissioningTimeout, byte[] PAKEVerifier, Integer discriminator, Long iterations, byte[] salt, Integer passcodeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void revokeCommissioning(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AdminFabricIndexAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readWindowStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readWindowStatusAttribute(IntegerAttributeCallback callback) { readWindowStatusAttribute(chipClusterPtr, callback); } + public void subscribeWindowStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWindowStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAdminFabricIndexAttribute( - AdminFabricIndexAttributeCallback callback - ) { + public void readAdminFabricIndexAttribute(AdminFabricIndexAttributeCallback callback) { readAdminFabricIndexAttribute(chipClusterPtr, callback); } + public void subscribeAdminFabricIndexAttribute( - AdminFabricIndexAttributeCallback callback - , - int minInterval, int maxInterval) { + AdminFabricIndexAttributeCallback callback, int minInterval, int maxInterval) { subscribeAdminFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAdminVendorIdAttribute( - IntegerAttributeCallback callback - ) { + public void readAdminVendorIdAttribute(IntegerAttributeCallback callback) { readAdminVendorIdAttribute(chipClusterPtr, callback); } + public void subscribeAdminVendorIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAdminVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readWindowStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeWindowStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAdminFabricIndexAttribute(long chipClusterPtr, - AdminFabricIndexAttributeCallback callback - ); - private native void subscribeAdminFabricIndexAttribute(long chipClusterPtr, - AdminFabricIndexAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readAdminVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAdminVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readWindowStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeWindowStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAdminFabricIndexAttribute( + long chipClusterPtr, AdminFabricIndexAttributeCallback callback); + + private native void subscribeAdminFabricIndexAttribute( + long chipClusterPtr, + AdminFabricIndexAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readAdminVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAdminVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ApplicationBasicCluster extends BaseChipCluster { @@ -467,187 +515,171 @@ public ApplicationBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AllowedVendorListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AllowedVendorListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readVendorNameAttribute( - CharStringAttributeCallback callback - ) { + public void readVendorNameAttribute(CharStringAttributeCallback callback) { readVendorNameAttribute(chipClusterPtr, callback); } + public void subscribeVendorNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIdAttribute( - IntegerAttributeCallback callback - ) { + public void readVendorIdAttribute(IntegerAttributeCallback callback) { readVendorIdAttribute(chipClusterPtr, callback); } + public void subscribeVendorIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationNameAttribute( - CharStringAttributeCallback callback - ) { + public void readApplicationNameAttribute(CharStringAttributeCallback callback) { readApplicationNameAttribute(chipClusterPtr, callback); } + public void subscribeApplicationNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductIdAttribute( - IntegerAttributeCallback callback - ) { + public void readProductIdAttribute(IntegerAttributeCallback callback) { readProductIdAttribute(chipClusterPtr, callback); } + public void subscribeProductIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readApplicationStatusAttribute(IntegerAttributeCallback callback) { readApplicationStatusAttribute(chipClusterPtr, callback); } + public void subscribeApplicationStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readApplicationVersionAttribute( - CharStringAttributeCallback callback - ) { + public void readApplicationVersionAttribute(CharStringAttributeCallback callback) { readApplicationVersionAttribute(chipClusterPtr, callback); } + public void subscribeApplicationVersionAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAllowedVendorListAttribute( - AllowedVendorListAttributeCallback callback - ) { + public void readAllowedVendorListAttribute(AllowedVendorListAttributeCallback callback) { readAllowedVendorListAttribute(chipClusterPtr, callback); } + public void subscribeAllowedVendorListAttribute( - AllowedVendorListAttributeCallback callback - , - int minInterval, int maxInterval) { + AllowedVendorListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAllowedVendorListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeVendorIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readApplicationNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeApplicationNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeProductIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readApplicationStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeApplicationStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readApplicationVersionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeApplicationVersionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAllowedVendorListAttribute(long chipClusterPtr, - AllowedVendorListAttributeCallback callback - ); - private native void subscribeAllowedVendorListAttribute(long chipClusterPtr, - AllowedVendorListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readVendorNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeVendorNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeVendorIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readApplicationNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeApplicationNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeProductIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readApplicationStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeApplicationStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readApplicationVersionAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeApplicationVersionAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readAllowedVendorListAttribute( + long chipClusterPtr, AllowedVendorListAttributeCallback callback); + + private native void subscribeAllowedVendorListAttribute( + long chipClusterPtr, + AllowedVendorListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ApplicationLauncherCluster extends BaseChipCluster { @@ -660,121 +692,139 @@ public ApplicationLauncherCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void hideAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void hideAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { hideAppRequest(chipClusterPtr, callback, application, null); } - public void hideAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , int timedInvokeTimeoutMs) { + public void hideAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + int timedInvokeTimeoutMs) { hideAppRequest(chipClusterPtr, callback, application, timedInvokeTimeoutMs); } - public void launchAppRequest(LauncherResponseCallback callback - , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void launchAppRequest( + LauncherResponseCallback callback, + String data, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { launchAppRequest(chipClusterPtr, callback, data, application, null); } - public void launchAppRequest(LauncherResponseCallback callback - , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , int timedInvokeTimeoutMs) { + public void launchAppRequest( + LauncherResponseCallback callback, + String data, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + int timedInvokeTimeoutMs) { launchAppRequest(chipClusterPtr, callback, data, application, timedInvokeTimeoutMs); } - public void stopAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { + public void stopAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application) { stopAppRequest(chipClusterPtr, callback, application, null); } - public void stopAppRequest(LauncherResponseCallback callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , int timedInvokeTimeoutMs) { + public void stopAppRequest( + LauncherResponseCallback callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + int timedInvokeTimeoutMs) { stopAppRequest(chipClusterPtr, callback, application, timedInvokeTimeoutMs); } - private native void hideAppRequest(long chipClusterPtr, LauncherResponseCallback Callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , @Nullable Integer timedInvokeTimeoutMs); - private native void launchAppRequest(long chipClusterPtr, LauncherResponseCallback Callback - , String data, ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopAppRequest(long chipClusterPtr, LauncherResponseCallback Callback - , ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , @Nullable Integer timedInvokeTimeoutMs); + + private native void hideAppRequest( + long chipClusterPtr, + LauncherResponseCallback Callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + @Nullable Integer timedInvokeTimeoutMs); + + private native void launchAppRequest( + long chipClusterPtr, + LauncherResponseCallback Callback, + String data, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopAppRequest( + long chipClusterPtr, + LauncherResponseCallback Callback, + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + @Nullable Integer timedInvokeTimeoutMs); + public interface LauncherResponseCallback { void onSuccess(Integer status, String data); void onError(Exception error); } + public interface ApplicationLauncherListAttributeCallback { + void onSuccess(List valueList); - public interface ApplicationLauncherListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } public void readApplicationLauncherListAttribute( - ApplicationLauncherListAttributeCallback callback - ) { + ApplicationLauncherListAttributeCallback callback) { readApplicationLauncherListAttribute(chipClusterPtr, callback); } + public void subscribeApplicationLauncherListAttribute( - ApplicationLauncherListAttributeCallback callback - , - int minInterval, int maxInterval) { + ApplicationLauncherListAttributeCallback callback, int minInterval, int maxInterval) { subscribeApplicationLauncherListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readApplicationLauncherListAttribute(long chipClusterPtr, - ApplicationLauncherListAttributeCallback callback - ); - private native void subscribeApplicationLauncherListAttribute(long chipClusterPtr, - ApplicationLauncherListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readApplicationLauncherListAttribute( + long chipClusterPtr, ApplicationLauncherListAttributeCallback callback); + + private native void subscribeApplicationLauncherListAttribute( + long chipClusterPtr, + ApplicationLauncherListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class AudioOutputCluster extends BaseChipCluster { @@ -787,120 +837,118 @@ public AudioOutputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void renameOutputRequest(DefaultClusterCallback callback - , Integer index, String name) { + public void renameOutputRequest(DefaultClusterCallback callback, Integer index, String name) { renameOutputRequest(chipClusterPtr, callback, index, name, null); } - public void renameOutputRequest(DefaultClusterCallback callback - , Integer index, String name - , int timedInvokeTimeoutMs) { + public void renameOutputRequest( + DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) { renameOutputRequest(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); } - public void selectOutputRequest(DefaultClusterCallback callback - , Integer index) { + public void selectOutputRequest(DefaultClusterCallback callback, Integer index) { selectOutputRequest(chipClusterPtr, callback, index, null); } - public void selectOutputRequest(DefaultClusterCallback callback - , Integer index - , int timedInvokeTimeoutMs) { + public void selectOutputRequest( + DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) { selectOutputRequest(chipClusterPtr, callback, index, timedInvokeTimeoutMs); } - private native void renameOutputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index, String name - , @Nullable Integer timedInvokeTimeoutMs); - private native void selectOutputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index - , @Nullable Integer timedInvokeTimeoutMs); - - public interface AudioOutputListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readAudioOutputListAttribute( - AudioOutputListAttributeCallback callback - ) { + private native void renameOutputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + String name, + @Nullable Integer timedInvokeTimeoutMs); + + private native void selectOutputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AudioOutputListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readAudioOutputListAttribute(AudioOutputListAttributeCallback callback) { readAudioOutputListAttribute(chipClusterPtr, callback); } + public void subscribeAudioOutputListAttribute( - AudioOutputListAttributeCallback callback - , - int minInterval, int maxInterval) { + AudioOutputListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAudioOutputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentAudioOutputAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentAudioOutputAttribute(IntegerAttributeCallback callback) { readCurrentAudioOutputAttribute(chipClusterPtr, callback); } + public void subscribeCurrentAudioOutputAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentAudioOutputAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAudioOutputListAttribute(long chipClusterPtr, - AudioOutputListAttributeCallback callback - ); - private native void subscribeAudioOutputListAttribute(long chipClusterPtr, - AudioOutputListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentAudioOutputAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentAudioOutputAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readAudioOutputListAttribute( + long chipClusterPtr, AudioOutputListAttributeCallback callback); + + private native void subscribeAudioOutputListAttribute( + long chipClusterPtr, + AudioOutputListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentAudioOutputAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentAudioOutputAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BarrierControlCluster extends BaseChipCluster { @@ -913,153 +961,135 @@ public BarrierControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void barrierControlGoToPercent(DefaultClusterCallback callback - , Integer percentOpen) { + public void barrierControlGoToPercent(DefaultClusterCallback callback, Integer percentOpen) { barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, null); } - public void barrierControlGoToPercent(DefaultClusterCallback callback - , Integer percentOpen - , int timedInvokeTimeoutMs) { + public void barrierControlGoToPercent( + DefaultClusterCallback callback, Integer percentOpen, int timedInvokeTimeoutMs) { barrierControlGoToPercent(chipClusterPtr, callback, percentOpen, timedInvokeTimeoutMs); } - public void barrierControlStop(DefaultClusterCallback callback - ) { + public void barrierControlStop(DefaultClusterCallback callback) { barrierControlStop(chipClusterPtr, callback, null); } - public void barrierControlStop(DefaultClusterCallback callback + public void barrierControlStop(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { barrierControlStop(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void barrierControlGoToPercent(long chipClusterPtr, DefaultClusterCallback Callback - , Integer percentOpen - , @Nullable Integer timedInvokeTimeoutMs); - private native void barrierControlStop(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void barrierControlGoToPercent( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer percentOpen, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void barrierControlStop( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readBarrierMovingStateAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readBarrierMovingStateAttribute(IntegerAttributeCallback callback) { readBarrierMovingStateAttribute(chipClusterPtr, callback); } + public void subscribeBarrierMovingStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierMovingStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierSafetyStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readBarrierSafetyStatusAttribute(IntegerAttributeCallback callback) { readBarrierSafetyStatusAttribute(chipClusterPtr, callback); } + public void subscribeBarrierSafetyStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierCapabilitiesAttribute( - IntegerAttributeCallback callback - ) { + public void readBarrierCapabilitiesAttribute(IntegerAttributeCallback callback) { readBarrierCapabilitiesAttribute(chipClusterPtr, callback); } + public void subscribeBarrierCapabilitiesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBarrierPositionAttribute( - IntegerAttributeCallback callback - ) { + public void readBarrierPositionAttribute(IntegerAttributeCallback callback) { readBarrierPositionAttribute(chipClusterPtr, callback); } + public void subscribeBarrierPositionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBarrierPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBarrierMovingStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierMovingStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBarrierSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBarrierCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBarrierPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBarrierPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readBarrierMovingStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierMovingStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBarrierSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBarrierCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBarrierPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBarrierPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BasicCluster extends BaseChipCluster { @@ -1072,442 +1102,420 @@ public BasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface VendorIDAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface VendorIDAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readInteractionModelVersionAttribute( - IntegerAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readInteractionModelVersionAttribute(IntegerAttributeCallback callback) { readInteractionModelVersionAttribute(chipClusterPtr, callback); } + public void subscribeInteractionModelVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInteractionModelVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorNameAttribute( - CharStringAttributeCallback callback - ) { + public void readVendorNameAttribute(CharStringAttributeCallback callback) { readVendorNameAttribute(chipClusterPtr, callback); } + public void subscribeVendorNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIDAttribute( - VendorIDAttributeCallback callback - ) { + public void readVendorIDAttribute(VendorIDAttributeCallback callback) { readVendorIDAttribute(chipClusterPtr, callback); } + public void subscribeVendorIDAttribute( - VendorIDAttributeCallback callback - , - int minInterval, int maxInterval) { + VendorIDAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductNameAttribute( - CharStringAttributeCallback callback - ) { + public void readProductNameAttribute(CharStringAttributeCallback callback) { readProductNameAttribute(chipClusterPtr, callback); } + public void subscribeProductNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductIDAttribute( - IntegerAttributeCallback callback - ) { + public void readProductIDAttribute(IntegerAttributeCallback callback) { readProductIDAttribute(chipClusterPtr, callback); } + public void subscribeProductIDAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNodeLabelAttribute( - CharStringAttributeCallback callback - ) { + public void readNodeLabelAttribute(CharStringAttributeCallback callback) { readNodeLabelAttribute(chipClusterPtr, callback); } + public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value) { writeNodeLabelAttribute(chipClusterPtr, callback, value, null); } - public void writeNodeLabelAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeNodeLabelAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeNodeLabelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNodeLabelAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNodeLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocationAttribute( - CharStringAttributeCallback callback - ) { + public void readLocationAttribute(CharStringAttributeCallback callback) { readLocationAttribute(chipClusterPtr, callback); } + public void writeLocationAttribute(DefaultClusterCallback callback, String value) { writeLocationAttribute(chipClusterPtr, callback, value, null); } - public void writeLocationAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLocationAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLocationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLocationAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readHardwareVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readHardwareVersionAttribute(IntegerAttributeCallback callback) { readHardwareVersionAttribute(chipClusterPtr, callback); } + public void subscribeHardwareVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeHardwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readHardwareVersionStringAttribute( - CharStringAttributeCallback callback - ) { + public void readHardwareVersionStringAttribute(CharStringAttributeCallback callback) { readHardwareVersionStringAttribute(chipClusterPtr, callback); } + public void subscribeHardwareVersionStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeHardwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoftwareVersionAttribute( - LongAttributeCallback callback - ) { + public void readSoftwareVersionAttribute(LongAttributeCallback callback) { readSoftwareVersionAttribute(chipClusterPtr, callback); } + public void subscribeSoftwareVersionAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeSoftwareVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoftwareVersionStringAttribute( - CharStringAttributeCallback callback - ) { + public void readSoftwareVersionStringAttribute(CharStringAttributeCallback callback) { readSoftwareVersionStringAttribute(chipClusterPtr, callback); } + public void subscribeSoftwareVersionStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeSoftwareVersionStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readManufacturingDateAttribute( - CharStringAttributeCallback callback - ) { + public void readManufacturingDateAttribute(CharStringAttributeCallback callback) { readManufacturingDateAttribute(chipClusterPtr, callback); } + public void subscribeManufacturingDateAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeManufacturingDateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartNumberAttribute( - CharStringAttributeCallback callback - ) { + public void readPartNumberAttribute(CharStringAttributeCallback callback) { readPartNumberAttribute(chipClusterPtr, callback); } + public void subscribePartNumberAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribePartNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductURLAttribute( - CharStringAttributeCallback callback - ) { + public void readProductURLAttribute(CharStringAttributeCallback callback) { readProductURLAttribute(chipClusterPtr, callback); } + public void subscribeProductURLAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductURLAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readProductLabelAttribute( - CharStringAttributeCallback callback - ) { + public void readProductLabelAttribute(CharStringAttributeCallback callback) { readProductLabelAttribute(chipClusterPtr, callback); } + public void subscribeProductLabelAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeProductLabelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSerialNumberAttribute( - CharStringAttributeCallback callback - ) { + public void readSerialNumberAttribute(CharStringAttributeCallback callback) { readSerialNumberAttribute(chipClusterPtr, callback); } + public void subscribeSerialNumberAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeSerialNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocalConfigDisabledAttribute( - BooleanAttributeCallback callback - ) { + public void readLocalConfigDisabledAttribute(BooleanAttributeCallback callback) { readLocalConfigDisabledAttribute(chipClusterPtr, callback); } + public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value) { writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, null); } - public void writeLocalConfigDisabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeLocalConfigDisabledAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeLocalConfigDisabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLocalConfigDisabledAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocalConfigDisabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readReachableAttribute( - BooleanAttributeCallback callback - ) { + public void readReachableAttribute(BooleanAttributeCallback callback) { readReachableAttribute(chipClusterPtr, callback); } + public void subscribeReachableAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeReachableAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUniqueIDAttribute( - CharStringAttributeCallback callback - ) { + public void readUniqueIDAttribute(CharStringAttributeCallback callback) { readUniqueIDAttribute(chipClusterPtr, callback); } + public void subscribeUniqueIDAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeUniqueIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readInteractionModelVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInteractionModelVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeVendorNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorIDAttribute(long chipClusterPtr, - VendorIDAttributeCallback callback - ); - private native void subscribeVendorIDAttribute(long chipClusterPtr, - VendorIDAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readProductNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeProductNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductIDAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeProductIDAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNodeLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeNodeLabelAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNodeLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLocationAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeLocationAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLocationAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readHardwareVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeHardwareVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readHardwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeHardwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSoftwareVersionAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeSoftwareVersionAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSoftwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeSoftwareVersionStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readManufacturingDateAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeManufacturingDateAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPartNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribePartNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductURLAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeProductURLAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readProductLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeProductLabelAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSerialNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeSerialNumberAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLocalConfigDisabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeLocalConfigDisabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLocalConfigDisabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readReachableAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeReachableAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUniqueIDAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeUniqueIDAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readInteractionModelVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInteractionModelVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readVendorNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeVendorNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readVendorIDAttribute( + long chipClusterPtr, VendorIDAttributeCallback callback); + + private native void subscribeVendorIDAttribute( + long chipClusterPtr, VendorIDAttributeCallback callback, int minInterval, int maxInterval); + + private native void readProductNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeProductNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductIDAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeProductIDAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNodeLabelAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeNodeLabelAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNodeLabelAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLocationAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeLocationAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLocationAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readHardwareVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeHardwareVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readHardwareVersionStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeHardwareVersionStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSoftwareVersionAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeSoftwareVersionAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSoftwareVersionStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeSoftwareVersionStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readManufacturingDateAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeManufacturingDateAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPartNumberAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribePartNumberAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductURLAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeProductURLAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readProductLabelAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeProductLabelAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSerialNumberAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeSerialNumberAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLocalConfigDisabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeLocalConfigDisabledAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLocalConfigDisabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readReachableAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeReachableAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUniqueIDAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeUniqueIDAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BinaryInputBasicCluster extends BaseChipCluster { @@ -1520,207 +1528,230 @@ public BinaryInputBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readOutOfServiceAttribute( - BooleanAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readOutOfServiceAttribute(BooleanAttributeCallback callback) { readOutOfServiceAttribute(chipClusterPtr, callback); } + public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value) { writeOutOfServiceAttribute(chipClusterPtr, callback, value, null); } - public void writeOutOfServiceAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeOutOfServiceAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeOutOfServiceAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOutOfServiceAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeOutOfServiceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPresentValueAttribute( - BooleanAttributeCallback callback - ) { + public void readPresentValueAttribute(BooleanAttributeCallback callback) { readPresentValueAttribute(chipClusterPtr, callback); } + public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value) { writePresentValueAttribute(chipClusterPtr, callback, value, null); } - public void writePresentValueAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writePresentValueAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writePresentValueAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribePresentValueAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribePresentValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStatusFlagsAttribute( - IntegerAttributeCallback callback - ) { + public void readStatusFlagsAttribute(IntegerAttributeCallback callback) { readStatusFlagsAttribute(chipClusterPtr, callback); } + public void subscribeStatusFlagsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStatusFlagsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOutOfServiceAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeOutOfServiceAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOutOfServiceAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPresentValueAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writePresentValueAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribePresentValueAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStatusFlagsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStatusFlagsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + private native void readOutOfServiceAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); - public static class BindingCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 30L; + private native void writeOutOfServiceAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); - public BindingCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void subscribeOutOfServiceAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPresentValueAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writePresentValueAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribePresentValueAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStatusFlagsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStatusFlagsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class BindingCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 30L; + + public BindingCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } @Override public native long initWithDevice(long devicePtr, int endpointId); - public void bind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId) { + public void bind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId) { bind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, null); } - public void bind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , int timedInvokeTimeoutMs) { + public void bind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + int timedInvokeTimeoutMs) { bind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); } - public void unbind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId) { + public void unbind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId) { unbind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, null); } - public void unbind(DefaultClusterCallback callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , int timedInvokeTimeoutMs) { - unbind(chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); + public void unbind( + DefaultClusterCallback callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + int timedInvokeTimeoutMs) { + unbind( + chipClusterPtr, callback, nodeId, groupId, endpointId, clusterId, timedInvokeTimeoutMs); } - private native void bind(long chipClusterPtr, DefaultClusterCallback Callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , @Nullable Integer timedInvokeTimeoutMs); - private native void unbind(long chipClusterPtr, DefaultClusterCallback Callback - , Long nodeId, Integer groupId, Integer endpointId, Long clusterId - , @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void bind( + long chipClusterPtr, + DefaultClusterCallback Callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void unbind( + long chipClusterPtr, + DefaultClusterCallback Callback, + Long nodeId, + Integer groupId, + Integer endpointId, + Long clusterId, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 BooleanStateCluster extends BaseChipCluster { @@ -1733,68 +1764,61 @@ public BooleanStateCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readStateValueAttribute( - BooleanAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readStateValueAttribute(BooleanAttributeCallback callback) { readStateValueAttribute(chipClusterPtr, callback); } + public void subscribeStateValueAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeStateValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readStateValueAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeStateValueAttribute(long chipClusterPtr, - BooleanAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readStateValueAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeStateValueAttribute( + long chipClusterPtr, BooleanAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BridgedActionsCluster extends BaseChipCluster { @@ -1807,284 +1831,375 @@ public BridgedActionsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void disableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void disableAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { disableAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void disableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void disableAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { disableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void disableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void disableActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void disableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - disableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void disableActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + disableActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void enableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void enableAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { enableAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void enableAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void enableAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { enableAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void enableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void enableActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void enableActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - enableActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void enableActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + enableActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void instantAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void instantAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { instantAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void instantAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void instantAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { instantAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void instantActionWithTransition(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Integer transitionTime) { - instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, null); + public void instantActionWithTransition( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Integer transitionTime) { + instantActionWithTransition( + chipClusterPtr, callback, actionID, invokeID, transitionTime, null); } - public void instantActionWithTransition(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Integer transitionTime - , int timedInvokeTimeoutMs) { - instantActionWithTransition(chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs); + public void instantActionWithTransition( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Integer transitionTime, + int timedInvokeTimeoutMs) { + instantActionWithTransition( + chipClusterPtr, callback, actionID, invokeID, transitionTime, timedInvokeTimeoutMs); } - public void pauseAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void pauseAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { pauseAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void pauseAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void pauseAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { pauseAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void pauseActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void pauseActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void pauseActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - pauseActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void pauseActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + pauseActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void resumeAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void resumeAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { resumeAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void resumeAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void resumeAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { resumeAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void startAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void startAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { startAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void startAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void startAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { startAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - public void startActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration) { + public void startActionWithDuration( + DefaultClusterCallback callback, Integer actionID, Optional invokeID, Long duration) { startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, null); } - public void startActionWithDuration(DefaultClusterCallback callback - , Integer actionID, Optional invokeID, Long duration - , int timedInvokeTimeoutMs) { - startActionWithDuration(chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); + public void startActionWithDuration( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + Long duration, + int timedInvokeTimeoutMs) { + startActionWithDuration( + chipClusterPtr, callback, actionID, invokeID, duration, timedInvokeTimeoutMs); } - public void stopAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID) { + public void stopAction( + DefaultClusterCallback callback, Integer actionID, Optional invokeID) { stopAction(chipClusterPtr, callback, actionID, invokeID, null); } - public void stopAction(DefaultClusterCallback callback - , Integer actionID, Optional invokeID - , int timedInvokeTimeoutMs) { + public void stopAction( + DefaultClusterCallback callback, + Integer actionID, + Optional invokeID, + int timedInvokeTimeoutMs) { stopAction(chipClusterPtr, callback, actionID, invokeID, timedInvokeTimeoutMs); } - private native void disableAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void disableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void enableAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void enableActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void instantAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void instantActionWithTransition(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void pauseAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void pauseActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void resumeAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void startAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - private native void startActionWithDuration(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID, Long duration - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopAction(long chipClusterPtr, DefaultClusterCallback Callback - , Integer actionID, Optional invokeID - , @Nullable Integer timedInvokeTimeoutMs); - - public interface ActionListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface EndpointListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readActionListAttribute( - ActionListAttributeCallback callback - ) { + private native void disableAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void disableActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enableAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enableActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void instantAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void instantActionWithTransition( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void pauseAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void pauseActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void resumeAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void startAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void startActionWithDuration( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + Long duration, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopAction( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer actionID, + Optional invokeID, + @Nullable Integer timedInvokeTimeoutMs); + + public interface ActionListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface EndpointListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readActionListAttribute(ActionListAttributeCallback callback) { readActionListAttribute(chipClusterPtr, callback); } + public void subscribeActionListAttribute( - ActionListAttributeCallback callback - , - int minInterval, int maxInterval) { + ActionListAttributeCallback callback, int minInterval, int maxInterval) { subscribeActionListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEndpointListAttribute( - EndpointListAttributeCallback callback - ) { + public void readEndpointListAttribute(EndpointListAttributeCallback callback) { readEndpointListAttribute(chipClusterPtr, callback); } + public void subscribeEndpointListAttribute( - EndpointListAttributeCallback callback - , - int minInterval, int maxInterval) { + EndpointListAttributeCallback callback, int minInterval, int maxInterval) { subscribeEndpointListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSetupUrlAttribute( - CharStringAttributeCallback callback - ) { + public void readSetupUrlAttribute(CharStringAttributeCallback callback) { readSetupUrlAttribute(chipClusterPtr, callback); } + public void subscribeSetupUrlAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeSetupUrlAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readActionListAttribute(long chipClusterPtr, - ActionListAttributeCallback callback - ); - private native void subscribeActionListAttribute(long chipClusterPtr, - ActionListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readEndpointListAttribute(long chipClusterPtr, - EndpointListAttributeCallback callback - ); - private native void subscribeEndpointListAttribute(long chipClusterPtr, - EndpointListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readSetupUrlAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeSetupUrlAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readActionListAttribute( + long chipClusterPtr, ActionListAttributeCallback callback); + + private native void subscribeActionListAttribute( + long chipClusterPtr, + ActionListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEndpointListAttribute( + long chipClusterPtr, EndpointListAttributeCallback callback); + + private native void subscribeEndpointListAttribute( + long chipClusterPtr, + EndpointListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSetupUrlAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeSetupUrlAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class BridgedDeviceBasicCluster extends BaseChipCluster { @@ -2097,49 +2212,46 @@ public BridgedDeviceBasicCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - private native void readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ChannelCluster extends BaseChipCluster { @@ -2152,121 +2264,129 @@ public ChannelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void changeChannelByNumberRequest(DefaultClusterCallback callback - , Integer majorNumber, Integer minorNumber) { + public void changeChannelByNumberRequest( + DefaultClusterCallback callback, Integer majorNumber, Integer minorNumber) { changeChannelByNumberRequest(chipClusterPtr, callback, majorNumber, minorNumber, null); } - public void changeChannelByNumberRequest(DefaultClusterCallback callback - , Integer majorNumber, Integer minorNumber - , int timedInvokeTimeoutMs) { - changeChannelByNumberRequest(chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs); + public void changeChannelByNumberRequest( + DefaultClusterCallback callback, + Integer majorNumber, + Integer minorNumber, + int timedInvokeTimeoutMs) { + changeChannelByNumberRequest( + chipClusterPtr, callback, majorNumber, minorNumber, timedInvokeTimeoutMs); } - public void changeChannelRequest(ChangeChannelResponseCallback callback - , String match) { + public void changeChannelRequest(ChangeChannelResponseCallback callback, String match) { changeChannelRequest(chipClusterPtr, callback, match, null); } - public void changeChannelRequest(ChangeChannelResponseCallback callback - , String match - , int timedInvokeTimeoutMs) { + public void changeChannelRequest( + ChangeChannelResponseCallback callback, String match, int timedInvokeTimeoutMs) { changeChannelRequest(chipClusterPtr, callback, match, timedInvokeTimeoutMs); } - public void skipChannelRequest(DefaultClusterCallback callback - , Integer count) { + public void skipChannelRequest(DefaultClusterCallback callback, Integer count) { skipChannelRequest(chipClusterPtr, callback, count, null); } - public void skipChannelRequest(DefaultClusterCallback callback - , Integer count - , int timedInvokeTimeoutMs) { + public void skipChannelRequest( + DefaultClusterCallback callback, Integer count, int timedInvokeTimeoutMs) { skipChannelRequest(chipClusterPtr, callback, count, timedInvokeTimeoutMs); } - private native void changeChannelByNumberRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer majorNumber, Integer minorNumber - , @Nullable Integer timedInvokeTimeoutMs); - private native void changeChannelRequest(long chipClusterPtr, ChangeChannelResponseCallback Callback - , String match - , @Nullable Integer timedInvokeTimeoutMs); - private native void skipChannelRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer count - , @Nullable Integer timedInvokeTimeoutMs); + + private native void changeChannelByNumberRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer majorNumber, + Integer minorNumber, + @Nullable Integer timedInvokeTimeoutMs); + + private native void changeChannelRequest( + long chipClusterPtr, + ChangeChannelResponseCallback Callback, + String match, + @Nullable Integer timedInvokeTimeoutMs); + + private native void skipChannelRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer count, + @Nullable Integer timedInvokeTimeoutMs); + public interface ChangeChannelResponseCallback { void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType); void onError(Exception error); } + public interface ChannelListAttributeCallback { + void onSuccess(List valueList); - public interface ChannelListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readChannelListAttribute( - ChannelListAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readChannelListAttribute(ChannelListAttributeCallback callback) { readChannelListAttribute(chipClusterPtr, callback); } + public void subscribeChannelListAttribute( - ChannelListAttributeCallback callback - , - int minInterval, int maxInterval) { + ChannelListAttributeCallback callback, int minInterval, int maxInterval) { subscribeChannelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readChannelListAttribute(long chipClusterPtr, - ChannelListAttributeCallback callback - ); - private native void subscribeChannelListAttribute(long chipClusterPtr, - ChannelListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readChannelListAttribute( + long chipClusterPtr, ChannelListAttributeCallback callback); + + private native void subscribeChannelListAttribute( + long chipClusterPtr, + ChannelListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ColorControlCluster extends BaseChipCluster { @@ -2279,1561 +2399,2031 @@ public ColorControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void colorLoopSet(DefaultClusterCallback callback - , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride) { - colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, null); - } - - public void colorLoopSet(DefaultClusterCallback callback - , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - colorLoopSet(chipClusterPtr, callback, updateFlags, action, direction, time, startHue, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedMoveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + public void colorLoopSet( + DefaultClusterCallback callback, + Integer updateFlags, + Integer action, + Integer direction, + Integer time, + Integer startHue, + Integer optionsMask, + Integer optionsOverride) { + colorLoopSet( + chipClusterPtr, + callback, + updateFlags, + action, + direction, + time, + startHue, + optionsMask, + optionsOverride, + null); + } + + public void colorLoopSet( + DefaultClusterCallback callback, + Integer updateFlags, + Integer action, + Integer direction, + Integer time, + Integer startHue, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + colorLoopSet( + chipClusterPtr, + callback, + updateFlags, + action, + direction, + time, + startHue, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedMoveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride) { enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void enhancedMoveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedMoveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedMoveToHue(DefaultClusterCallback callback - , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, null); - } - - public void enhancedMoveToHue(DefaultClusterCallback callback - , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedMoveToHue(chipClusterPtr, callback, enhancedHue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback - , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, null); - } - - public void enhancedMoveToHueAndSaturation(DefaultClusterCallback callback - , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedMoveToHueAndSaturation(chipClusterPtr, callback, enhancedHue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void enhancedStepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); - } - - public void enhancedStepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - enhancedStepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveColor(DefaultClusterCallback callback - , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride) { + public void enhancedMoveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedMoveHue( + chipClusterPtr, + callback, + moveMode, + rate, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedMoveToHue( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + enhancedMoveToHue( + chipClusterPtr, + callback, + enhancedHue, + direction, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void enhancedMoveToHue( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedMoveToHue( + chipClusterPtr, + callback, + enhancedHue, + direction, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedMoveToHueAndSaturation( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + enhancedMoveToHueAndSaturation( + chipClusterPtr, + callback, + enhancedHue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void enhancedMoveToHueAndSaturation( + DefaultClusterCallback callback, + Integer enhancedHue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedMoveToHueAndSaturation( + chipClusterPtr, + callback, + enhancedHue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void enhancedStepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + enhancedStepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void enhancedStepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + enhancedStepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveColor( + DefaultClusterCallback callback, + Integer rateX, + Integer rateY, + Integer optionsMask, + Integer optionsOverride) { moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, null); } - public void moveColor(DefaultClusterCallback callback - , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveColor(chipClusterPtr, callback, rateX, rateY, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveColorTemperature(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride) { - moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, null); - } - - public void moveColorTemperature(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveColorTemperature(chipClusterPtr, callback, moveMode, rate, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + public void moveColor( + DefaultClusterCallback callback, + Integer rateX, + Integer rateY, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveColor( + chipClusterPtr, + callback, + rateX, + rateY, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveColorTemperature( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride) { + moveColorTemperature( + chipClusterPtr, + callback, + moveMode, + rate, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + null); + } + + public void moveColorTemperature( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveColorTemperature( + chipClusterPtr, + callback, + moveMode, + rate, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride) { moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void moveHue(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveHue(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveSaturation(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride) { + public void moveHue( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveHue( + chipClusterPtr, + callback, + moveMode, + rate, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveSaturation( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride) { moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, null); } - public void moveSaturation(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveSaturation(chipClusterPtr, callback, moveMode, rate, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToColor(DefaultClusterCallback callback - , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToColor(DefaultClusterCallback callback - , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToColor(chipClusterPtr, callback, colorX, colorY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToColorTemperature(DefaultClusterCallback callback - , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToColorTemperature(chipClusterPtr, callback, colorTemperature, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToColorTemperature(DefaultClusterCallback callback - , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToColorTemperature(chipClusterPtr, callback, colorTemperature, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToHue(DefaultClusterCallback callback - , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToHue(DefaultClusterCallback callback - , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToHue(chipClusterPtr, callback, hue, direction, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToHueAndSaturation(DefaultClusterCallback callback - , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToHueAndSaturation(DefaultClusterCallback callback - , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToHueAndSaturation(chipClusterPtr, callback, hue, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void moveToSaturation(DefaultClusterCallback callback - , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null); - } - - public void moveToSaturation(DefaultClusterCallback callback - , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - moveToSaturation(chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepColor(DefaultClusterCallback callback - , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, null); - } - - public void stepColor(DefaultClusterCallback callback - , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepColor(chipClusterPtr, callback, stepX, stepY, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepColorTemperature(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride) { - stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, null); - } - - public void stepColorTemperature(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepColorTemperature(chipClusterPtr, callback, stepMode, stepSize, transitionTime, colorTemperatureMinimum, colorTemperatureMaximum, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); - } - - public void stepHue(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepHue(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stepSaturation(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride) { - stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, null); - } - - public void stepSaturation(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { - stepSaturation(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionsMask, optionsOverride, timedInvokeTimeoutMs); - } - - public void stopMoveStep(DefaultClusterCallback callback - , Integer optionsMask, Integer optionsOverride) { + public void moveSaturation( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveSaturation( + chipClusterPtr, + callback, + moveMode, + rate, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToColor( + DefaultClusterCallback callback, + Integer colorX, + Integer colorY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToColor( + chipClusterPtr, + callback, + colorX, + colorY, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToColor( + DefaultClusterCallback callback, + Integer colorX, + Integer colorY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToColor( + chipClusterPtr, + callback, + colorX, + colorY, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToColorTemperature( + DefaultClusterCallback callback, + Integer colorTemperature, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToColorTemperature( + chipClusterPtr, + callback, + colorTemperature, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToColorTemperature( + DefaultClusterCallback callback, + Integer colorTemperature, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToColorTemperature( + chipClusterPtr, + callback, + colorTemperature, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToHue( + DefaultClusterCallback callback, + Integer hue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToHue( + chipClusterPtr, + callback, + hue, + direction, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToHue( + DefaultClusterCallback callback, + Integer hue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToHue( + chipClusterPtr, + callback, + hue, + direction, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToHueAndSaturation( + DefaultClusterCallback callback, + Integer hue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToHueAndSaturation( + chipClusterPtr, + callback, + hue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void moveToHueAndSaturation( + DefaultClusterCallback callback, + Integer hue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToHueAndSaturation( + chipClusterPtr, + callback, + hue, + saturation, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void moveToSaturation( + DefaultClusterCallback callback, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + moveToSaturation( + chipClusterPtr, callback, saturation, transitionTime, optionsMask, optionsOverride, null); + } + + public void moveToSaturation( + DefaultClusterCallback callback, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + moveToSaturation( + chipClusterPtr, + callback, + saturation, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepColor( + DefaultClusterCallback callback, + Integer stepX, + Integer stepY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + stepColor( + chipClusterPtr, + callback, + stepX, + stepY, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void stepColor( + DefaultClusterCallback callback, + Integer stepX, + Integer stepY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepColor( + chipClusterPtr, + callback, + stepX, + stepY, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepColorTemperature( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride) { + stepColorTemperature( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + null); + } + + public void stepColorTemperature( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepColorTemperature( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + colorTemperatureMinimum, + colorTemperatureMaximum, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + stepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void stepHue( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepHue( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stepSaturation( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride) { + stepSaturation( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + null); + } + + public void stepSaturation( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { + stepSaturation( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionsMask, + optionsOverride, + timedInvokeTimeoutMs); + } + + public void stopMoveStep( + DefaultClusterCallback callback, Integer optionsMask, Integer optionsOverride) { stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, null); } - public void stopMoveStep(DefaultClusterCallback callback - , Integer optionsMask, Integer optionsOverride - , int timedInvokeTimeoutMs) { + public void stopMoveStep( + DefaultClusterCallback callback, + Integer optionsMask, + Integer optionsOverride, + int timedInvokeTimeoutMs) { stopMoveStep(chipClusterPtr, callback, optionsMask, optionsOverride, timedInvokeTimeoutMs); } - private native void colorLoopSet(long chipClusterPtr, DefaultClusterCallback Callback - , Integer updateFlags, Integer action, Integer direction, Integer time, Integer startHue, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedMoveHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedMoveToHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer enhancedHue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedMoveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer enhancedHue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void enhancedStepHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveColor(long chipClusterPtr, DefaultClusterCallback Callback - , Integer rateX, Integer rateY, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToColor(long chipClusterPtr, DefaultClusterCallback Callback - , Integer colorX, Integer colorY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback - , Integer colorTemperature, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer hue, Integer direction, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToHueAndSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer hue, Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer saturation, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepColor(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepX, Integer stepY, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepColorTemperature(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer colorTemperatureMinimum, Integer colorTemperatureMaximum, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepHue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepSaturation(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopMoveStep(long chipClusterPtr, DefaultClusterCallback Callback - , Integer optionsMask, Integer optionsOverride - , @Nullable Integer timedInvokeTimeoutMs); - - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readCurrentHueAttribute( - IntegerAttributeCallback callback - ) { + private native void colorLoopSet( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer updateFlags, + Integer action, + Integer direction, + Integer time, + Integer startHue, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedMoveHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedMoveToHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer enhancedHue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedMoveToHueAndSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer enhancedHue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void enhancedStepHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveColor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer rateX, + Integer rateY, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveColorTemperature( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToColor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer colorX, + Integer colorY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToColorTemperature( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer colorTemperature, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer hue, + Integer direction, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToHueAndSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer hue, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer saturation, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepColor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepX, + Integer stepY, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepColorTemperature( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer colorTemperatureMinimum, + Integer colorTemperatureMaximum, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepHue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepSaturation( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopMoveStep( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer optionsMask, + Integer optionsOverride, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readCurrentHueAttribute(IntegerAttributeCallback callback) { readCurrentHueAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentSaturationAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentSaturationAttribute(IntegerAttributeCallback callback) { readCurrentSaturationAttribute(chipClusterPtr, callback); } + public void subscribeCurrentSaturationAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentSaturationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRemainingTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readRemainingTimeAttribute(IntegerAttributeCallback callback) { readRemainingTimeAttribute(chipClusterPtr, callback); } + public void subscribeRemainingTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentXAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentXAttribute(IntegerAttributeCallback callback) { readCurrentXAttribute(chipClusterPtr, callback); } + public void subscribeCurrentXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentYAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentYAttribute(IntegerAttributeCallback callback) { readCurrentYAttribute(chipClusterPtr, callback); } + public void subscribeCurrentYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDriftCompensationAttribute( - IntegerAttributeCallback callback - ) { + public void readDriftCompensationAttribute(IntegerAttributeCallback callback) { readDriftCompensationAttribute(chipClusterPtr, callback); } + public void subscribeDriftCompensationAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeDriftCompensationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCompensationTextAttribute( - CharStringAttributeCallback callback - ) { + public void readCompensationTextAttribute(CharStringAttributeCallback callback) { readCompensationTextAttribute(chipClusterPtr, callback); } + public void subscribeCompensationTextAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeCompensationTextAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTemperatureAttribute( - IntegerAttributeCallback callback - ) { + public void readColorTemperatureAttribute(IntegerAttributeCallback callback) { readColorTemperatureAttribute(chipClusterPtr, callback); } + public void subscribeColorTemperatureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorModeAttribute( - IntegerAttributeCallback callback - ) { + public void readColorModeAttribute(IntegerAttributeCallback callback) { readColorModeAttribute(chipClusterPtr, callback); } + public void subscribeColorModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorControlOptionsAttribute( - IntegerAttributeCallback callback - ) { + public void readColorControlOptionsAttribute(IntegerAttributeCallback callback) { readColorControlOptionsAttribute(chipClusterPtr, callback); } + public void writeColorControlOptionsAttribute(DefaultClusterCallback callback, Integer value) { writeColorControlOptionsAttribute(chipClusterPtr, callback, value, null); } - public void writeColorControlOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorControlOptionsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorControlOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorControlOptionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorControlOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfPrimariesAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfPrimariesAttribute(IntegerAttributeCallback callback) { readNumberOfPrimariesAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfPrimariesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNumberOfPrimariesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary1XAttribute(IntegerAttributeCallback callback) { readPrimary1XAttribute(chipClusterPtr, callback); } + public void subscribePrimary1XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary1XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary1YAttribute(IntegerAttributeCallback callback) { readPrimary1YAttribute(chipClusterPtr, callback); } + public void subscribePrimary1YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary1YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary1IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary1IntensityAttribute(IntegerAttributeCallback callback) { readPrimary1IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary1IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary1IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary2XAttribute(IntegerAttributeCallback callback) { readPrimary2XAttribute(chipClusterPtr, callback); } + public void subscribePrimary2XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary2XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary2YAttribute(IntegerAttributeCallback callback) { readPrimary2YAttribute(chipClusterPtr, callback); } + public void subscribePrimary2YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary2YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary2IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary2IntensityAttribute(IntegerAttributeCallback callback) { readPrimary2IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary2IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary2IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary3XAttribute(IntegerAttributeCallback callback) { readPrimary3XAttribute(chipClusterPtr, callback); } + public void subscribePrimary3XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary3XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary3YAttribute(IntegerAttributeCallback callback) { readPrimary3YAttribute(chipClusterPtr, callback); } + public void subscribePrimary3YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary3YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary3IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary3IntensityAttribute(IntegerAttributeCallback callback) { readPrimary3IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary3IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary3IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary4XAttribute(IntegerAttributeCallback callback) { readPrimary4XAttribute(chipClusterPtr, callback); } + public void subscribePrimary4XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary4XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary4YAttribute(IntegerAttributeCallback callback) { readPrimary4YAttribute(chipClusterPtr, callback); } + public void subscribePrimary4YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary4YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary4IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary4IntensityAttribute(IntegerAttributeCallback callback) { readPrimary4IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary4IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary4IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary5XAttribute(IntegerAttributeCallback callback) { readPrimary5XAttribute(chipClusterPtr, callback); } + public void subscribePrimary5XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary5XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary5YAttribute(IntegerAttributeCallback callback) { readPrimary5YAttribute(chipClusterPtr, callback); } + public void subscribePrimary5YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary5YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary5IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary5IntensityAttribute(IntegerAttributeCallback callback) { readPrimary5IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary5IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary5IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6XAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary6XAttribute(IntegerAttributeCallback callback) { readPrimary6XAttribute(chipClusterPtr, callback); } + public void subscribePrimary6XAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary6XAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6YAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary6YAttribute(IntegerAttributeCallback callback) { readPrimary6YAttribute(chipClusterPtr, callback); } + public void subscribePrimary6YAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary6YAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPrimary6IntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readPrimary6IntensityAttribute(IntegerAttributeCallback callback) { readPrimary6IntensityAttribute(chipClusterPtr, callback); } + public void subscribePrimary6IntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePrimary6IntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWhitePointXAttribute( - IntegerAttributeCallback callback - ) { + public void readWhitePointXAttribute(IntegerAttributeCallback callback) { readWhitePointXAttribute(chipClusterPtr, callback); } + public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value) { writeWhitePointXAttribute(chipClusterPtr, callback, value, null); } - public void writeWhitePointXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWhitePointXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWhitePointXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeWhitePointXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWhitePointXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWhitePointYAttribute( - IntegerAttributeCallback callback - ) { + public void readWhitePointYAttribute(IntegerAttributeCallback callback) { readWhitePointYAttribute(chipClusterPtr, callback); } + public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value) { writeWhitePointYAttribute(chipClusterPtr, callback, value, null); } - public void writeWhitePointYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWhitePointYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWhitePointYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeWhitePointYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWhitePointYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRXAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointRXAttribute(IntegerAttributeCallback callback) { readColorPointRXAttribute(chipClusterPtr, callback); } + public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointRXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointRXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRYAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointRYAttribute(IntegerAttributeCallback callback) { readColorPointRYAttribute(chipClusterPtr, callback); } + public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointRYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointRYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointRIntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointRIntensityAttribute(IntegerAttributeCallback callback) { readColorPointRIntensityAttribute(chipClusterPtr, callback); } + public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointRIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointRIntensityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointRIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointRIntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointRIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGXAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointGXAttribute(IntegerAttributeCallback callback) { readColorPointGXAttribute(chipClusterPtr, callback); } + public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointGXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointGXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGYAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointGYAttribute(IntegerAttributeCallback callback) { readColorPointGYAttribute(chipClusterPtr, callback); } + public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointGYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointGYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointGIntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointGIntensityAttribute(IntegerAttributeCallback callback) { readColorPointGIntensityAttribute(chipClusterPtr, callback); } + public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointGIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointGIntensityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointGIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointGIntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointGIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBXAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointBXAttribute(IntegerAttributeCallback callback) { readColorPointBXAttribute(chipClusterPtr, callback); } + public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBXAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBXAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBXAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBXAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointBXAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointBXAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBYAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointBYAttribute(IntegerAttributeCallback callback) { readColorPointBYAttribute(chipClusterPtr, callback); } + public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBYAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBYAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBYAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBYAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointBYAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointBYAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorPointBIntensityAttribute( - IntegerAttributeCallback callback - ) { + public void readColorPointBIntensityAttribute(IntegerAttributeCallback callback) { readColorPointBIntensityAttribute(chipClusterPtr, callback); } + public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value) { writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, null); } - public void writeColorPointBIntensityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeColorPointBIntensityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeColorPointBIntensityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeColorPointBIntensityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorPointBIntensityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnhancedCurrentHueAttribute( - IntegerAttributeCallback callback - ) { + public void readEnhancedCurrentHueAttribute(IntegerAttributeCallback callback) { readEnhancedCurrentHueAttribute(chipClusterPtr, callback); } + public void subscribeEnhancedCurrentHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnhancedCurrentHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnhancedColorModeAttribute( - IntegerAttributeCallback callback - ) { + public void readEnhancedColorModeAttribute(IntegerAttributeCallback callback) { readEnhancedColorModeAttribute(chipClusterPtr, callback); } + public void subscribeEnhancedColorModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnhancedColorModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopActiveAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopActiveAttribute(IntegerAttributeCallback callback) { readColorLoopActiveAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopActiveAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorLoopActiveAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopDirectionAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopDirectionAttribute(IntegerAttributeCallback callback) { readColorLoopDirectionAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopDirectionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorLoopDirectionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopTimeAttribute(IntegerAttributeCallback callback) { readColorLoopTimeAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorLoopTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopStartEnhancedHueAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopStartEnhancedHueAttribute(IntegerAttributeCallback callback) { readColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopStartEnhancedHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeColorLoopStartEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeColorLoopStartEnhancedHueAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorLoopStoredEnhancedHueAttribute( - IntegerAttributeCallback callback - ) { + public void readColorLoopStoredEnhancedHueAttribute(IntegerAttributeCallback callback) { readColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback); } + public void subscribeColorLoopStoredEnhancedHueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeColorLoopStoredEnhancedHueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeColorLoopStoredEnhancedHueAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorCapabilitiesAttribute( - IntegerAttributeCallback callback - ) { + public void readColorCapabilitiesAttribute(IntegerAttributeCallback callback) { readColorCapabilitiesAttribute(chipClusterPtr, callback); } + public void subscribeColorCapabilitiesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorCapabilitiesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTempPhysicalMinAttribute( - IntegerAttributeCallback callback - ) { + public void readColorTempPhysicalMinAttribute(IntegerAttributeCallback callback) { readColorTempPhysicalMinAttribute(chipClusterPtr, callback); } + public void subscribeColorTempPhysicalMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorTempPhysicalMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readColorTempPhysicalMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readColorTempPhysicalMaxAttribute(IntegerAttributeCallback callback) { readColorTempPhysicalMaxAttribute(chipClusterPtr, callback); } + public void subscribeColorTempPhysicalMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeColorTempPhysicalMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCoupleColorTempToLevelMinMiredsAttribute( - IntegerAttributeCallback callback - ) { + public void readCoupleColorTempToLevelMinMiredsAttribute(IntegerAttributeCallback callback) { readCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback); } + public void subscribeCoupleColorTempToLevelMinMiredsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeCoupleColorTempToLevelMinMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCoupleColorTempToLevelMinMiredsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpColorTemperatureMiredsAttribute( - IntegerAttributeCallback callback - ) { + public void readStartUpColorTemperatureMiredsAttribute(IntegerAttributeCallback callback) { readStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback); } - public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeStartUpColorTemperatureMiredsAttribute( + DefaultClusterCallback callback, Integer value) { writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpColorTemperatureMiredsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeStartUpColorTemperatureMiredsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeStartUpColorTemperatureMiredsAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeStartUpColorTemperatureMiredsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeStartUpColorTemperatureMiredsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeStartUpColorTemperatureMiredsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentSaturationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentSaturationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDriftCompensationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeDriftCompensationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCompensationTextAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeCompensationTextAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorControlOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorControlOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorControlOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfPrimariesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfPrimariesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary1XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary1XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary1YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary1YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary1IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary1IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary2XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary2XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary2YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary2YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary2IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary2IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary3XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary3XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary3YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary3YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary3IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary3IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary4XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary4XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary4YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary4YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary4IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary4IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary5XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary5XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary5YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary5YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary5IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary5IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary6XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary6XAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary6YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary6YAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPrimary6IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePrimary6IntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWhitePointXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeWhitePointXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeWhitePointXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWhitePointYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeWhitePointYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeWhitePointYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointRXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointRXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointRXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointRYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointRYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointRYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointRIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointRIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointRIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointGXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointGXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointGXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointGYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointGYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointGYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointGIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointGIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointGIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointBXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointBXAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointBXAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointBYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointBYAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointBYAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorPointBIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeColorPointBIntensityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeColorPointBIntensityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnhancedCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEnhancedCurrentHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnhancedColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEnhancedColorModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopActiveAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopActiveAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopDirectionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopDirectionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopStartEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopStartEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorLoopStoredEnhancedHueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorCapabilitiesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorTempPhysicalMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorTempPhysicalMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readColorTempPhysicalMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeColorTempPhysicalMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCoupleColorTempToLevelMinMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeStartUpColorTemperatureMiredsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + private native void readCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public static class ContentLauncherCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1290L; + private native void subscribeCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public ContentLauncherCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void readCurrentSaturationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - @Override - public native long initWithDevice(long devicePtr, int endpointId); + private native void subscribeCurrentSaturationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void launchContentRequest(LaunchResponseCallback callback - , Boolean autoPlay, String data, ArrayList search) { - launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, null); - } + private native void readRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void launchContentRequest(LaunchResponseCallback callback - , Boolean autoPlay, String data, ArrayList search - , int timedInvokeTimeoutMs) { - launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, timedInvokeTimeoutMs); - } + private native void subscribeRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void launchURLRequest(LaunchResponseCallback callback - , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation) { - launchURLRequest(chipClusterPtr, callback, contentURL, displayString, brandingInformation, null); - } + private native void readCurrentXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void launchURLRequest(LaunchResponseCallback callback - , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation - , int timedInvokeTimeoutMs) { - launchURLRequest(chipClusterPtr, callback, contentURL, displayString, brandingInformation, timedInvokeTimeoutMs); - } - private native void launchContentRequest(long chipClusterPtr, LaunchResponseCallback Callback - , Boolean autoPlay, String data, ArrayList search - , @Nullable Integer timedInvokeTimeoutMs); - private native void launchURLRequest(long chipClusterPtr, LaunchResponseCallback Callback - , String contentURL, String displayString, ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation - , @Nullable Integer timedInvokeTimeoutMs); - public interface LaunchResponseCallback { - void onSuccess(Integer status, String data); + private native void subscribeCurrentXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - void onError(Exception error); - } + private native void readCurrentYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + private native void subscribeCurrentYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public interface AcceptHeaderListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void readDriftCompensationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readAcceptHeaderListAttribute( - AcceptHeaderListAttributeCallback callback - ) { - readAcceptHeaderListAttribute(chipClusterPtr, callback); - } - public void subscribeAcceptHeaderListAttribute( - AcceptHeaderListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAcceptHeaderListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeDriftCompensationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readSupportedStreamingProtocolsAttribute( - LongAttributeCallback callback - ) { - readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback); - } - public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value) { - writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, null); - } + private native void readCompensationTextAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); - public void writeSupportedStreamingProtocolsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { - writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); - } - public void subscribeSupportedStreamingProtocolsAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeCompensationTextAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { - readAttributeListAttribute(chipClusterPtr, callback); - } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readColorTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { - readClusterRevisionAttribute(chipClusterPtr, callback); - } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + private native void subscribeColorTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorControlOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorControlOptionsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorControlOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfPrimariesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfPrimariesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary1XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary1XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary1YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary1YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary1IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary1IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary2XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary2XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary2YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary2YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary2IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary2IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary3XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary3XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary3YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary3YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary3IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary3IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary4XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary4XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary4YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary4YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary4IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary4IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary5XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary5XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary5YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary5YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary5IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary5IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary6XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary6XAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary6YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary6YAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPrimary6IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePrimary6IntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWhitePointXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeWhitePointXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeWhitePointXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWhitePointYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeWhitePointYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeWhitePointYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointRXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointRXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointRXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointRYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointRYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointRYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointRIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointRIntensityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointRIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointGXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointGXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointGXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointGYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointGYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointGYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointGIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointGIntensityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointGIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointBXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointBXAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointBXAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointBYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointBYAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointBYAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorPointBIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeColorPointBIntensityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeColorPointBIntensityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnhancedCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEnhancedCurrentHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnhancedColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEnhancedColorModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopActiveAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopActiveAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopDirectionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopDirectionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopStartEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopStartEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorLoopStoredEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorLoopStoredEnhancedHueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorCapabilitiesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorTempPhysicalMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readColorTempPhysicalMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeColorTempPhysicalMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCoupleColorTempToLevelMinMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCoupleColorTempToLevelMinMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartUpColorTemperatureMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeStartUpColorTemperatureMiredsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeStartUpColorTemperatureMiredsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class ContentLauncherCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1290L; + + public ContentLauncherCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void launchContentRequest( + LaunchResponseCallback callback, + Boolean autoPlay, + String data, + ArrayList search) { + launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, null); + } + + public void launchContentRequest( + LaunchResponseCallback callback, + Boolean autoPlay, + String data, + ArrayList search, + int timedInvokeTimeoutMs) { + launchContentRequest(chipClusterPtr, callback, autoPlay, data, search, timedInvokeTimeoutMs); + } + + public void launchURLRequest( + LaunchResponseCallback callback, + String contentURL, + String displayString, + ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation) { + launchURLRequest( + chipClusterPtr, callback, contentURL, displayString, brandingInformation, null); + } + + public void launchURLRequest( + LaunchResponseCallback callback, + String contentURL, + String displayString, + ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation, + int timedInvokeTimeoutMs) { + launchURLRequest( + chipClusterPtr, + callback, + contentURL, + displayString, + brandingInformation, + timedInvokeTimeoutMs); + } + + private native void launchContentRequest( + long chipClusterPtr, + LaunchResponseCallback Callback, + Boolean autoPlay, + String data, + ArrayList search, + @Nullable Integer timedInvokeTimeoutMs); + + private native void launchURLRequest( + long chipClusterPtr, + LaunchResponseCallback Callback, + String contentURL, + String displayString, + ChipStructs.ContentLauncherClusterBrandingInformation brandingInformation, + @Nullable Integer timedInvokeTimeoutMs); + + public interface LaunchResponseCallback { + void onSuccess(Integer status, String data); + + void onError(Exception error); + } + + public interface AcceptHeaderListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readAcceptHeaderListAttribute(AcceptHeaderListAttributeCallback callback) { + readAcceptHeaderListAttribute(chipClusterPtr, callback); + } + + public void subscribeAcceptHeaderListAttribute( + AcceptHeaderListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeAcceptHeaderListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readSupportedStreamingProtocolsAttribute(LongAttributeCallback callback) { + readSupportedStreamingProtocolsAttribute(chipClusterPtr, callback); + } + + public void writeSupportedStreamingProtocolsAttribute( + DefaultClusterCallback callback, Long value) { + writeSupportedStreamingProtocolsAttribute(chipClusterPtr, callback, value, null); + } + + public void writeSupportedStreamingProtocolsAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + writeSupportedStreamingProtocolsAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + + public void subscribeSupportedStreamingProtocolsAttribute( + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeSupportedStreamingProtocolsAttribute( + 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 readClusterRevisionAttribute(IntegerAttributeCallback callback) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + + public void subscribeClusterRevisionAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAcceptHeaderListAttribute(long chipClusterPtr, - AcceptHeaderListAttributeCallback callback - ); - private native void subscribeAcceptHeaderListAttribute(long chipClusterPtr, - AcceptHeaderListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readSupportedStreamingProtocolsAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeSupportedStreamingProtocolsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSupportedStreamingProtocolsAttribute(long chipClusterPtr, - LongAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readAcceptHeaderListAttribute( + long chipClusterPtr, AcceptHeaderListAttributeCallback callback); + + private native void subscribeAcceptHeaderListAttribute( + long chipClusterPtr, + AcceptHeaderListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSupportedStreamingProtocolsAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void writeSupportedStreamingProtocolsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSupportedStreamingProtocolsAttribute( + long chipClusterPtr, LongAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class DescriptorCluster extends BaseChipCluster { @@ -3846,145 +4436,147 @@ public DescriptorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface DeviceListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ServerListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ClientListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface PartsListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface DeviceListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ServerListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ClientListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface PartsListAttributeCallback { + void onSuccess(List valueList); - public void readDeviceListAttribute( - DeviceListAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readDeviceListAttribute(DeviceListAttributeCallback callback) { readDeviceListAttribute(chipClusterPtr, callback); } + public void subscribeDeviceListAttribute( - DeviceListAttributeCallback callback - , - int minInterval, int maxInterval) { + DeviceListAttributeCallback callback, int minInterval, int maxInterval) { subscribeDeviceListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readServerListAttribute( - ServerListAttributeCallback callback - ) { + public void readServerListAttribute(ServerListAttributeCallback callback) { readServerListAttribute(chipClusterPtr, callback); } + public void subscribeServerListAttribute( - ServerListAttributeCallback callback - , - int minInterval, int maxInterval) { + ServerListAttributeCallback callback, int minInterval, int maxInterval) { subscribeServerListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClientListAttribute( - ClientListAttributeCallback callback - ) { + public void readClientListAttribute(ClientListAttributeCallback callback) { readClientListAttribute(chipClusterPtr, callback); } + public void subscribeClientListAttribute( - ClientListAttributeCallback callback - , - int minInterval, int maxInterval) { + ClientListAttributeCallback callback, int minInterval, int maxInterval) { subscribeClientListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartsListAttribute( - PartsListAttributeCallback callback - ) { + public void readPartsListAttribute(PartsListAttributeCallback callback) { readPartsListAttribute(chipClusterPtr, callback); } + public void subscribePartsListAttribute( - PartsListAttributeCallback callback - , - int minInterval, int maxInterval) { + PartsListAttributeCallback callback, int minInterval, int maxInterval) { subscribePartsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readDeviceListAttribute(long chipClusterPtr, - DeviceListAttributeCallback callback - ); - private native void subscribeDeviceListAttribute(long chipClusterPtr, - DeviceListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readServerListAttribute(long chipClusterPtr, - ServerListAttributeCallback callback - ); - private native void subscribeServerListAttribute(long chipClusterPtr, - ServerListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readClientListAttribute(long chipClusterPtr, - ClientListAttributeCallback callback - ); - private native void subscribeClientListAttribute(long chipClusterPtr, - ClientListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readPartsListAttribute(long chipClusterPtr, - PartsListAttributeCallback callback - ); - private native void subscribePartsListAttribute(long chipClusterPtr, - PartsListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readDeviceListAttribute( + long chipClusterPtr, DeviceListAttributeCallback callback); + + private native void subscribeDeviceListAttribute( + long chipClusterPtr, + DeviceListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readServerListAttribute( + long chipClusterPtr, ServerListAttributeCallback callback); + + private native void subscribeServerListAttribute( + long chipClusterPtr, + ServerListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readClientListAttribute( + long chipClusterPtr, ClientListAttributeCallback callback); + + private native void subscribeClientListAttribute( + long chipClusterPtr, + ClientListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPartsListAttribute( + long chipClusterPtr, PartsListAttributeCallback callback); + + private native void subscribePartsListAttribute( + long chipClusterPtr, PartsListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class DiagnosticLogsCluster extends BaseChipCluster { @@ -3997,50 +4589,69 @@ public DiagnosticLogsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void retrieveLogsRequest(RetrieveLogsResponseCallback callback - , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator) { - retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null); - } + public void retrieveLogsRequest( + RetrieveLogsResponseCallback callback, + Integer intent, + Integer requestedProtocol, + byte[] transferFileDesignator) { + retrieveLogsRequest( + chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, null); + } + + public void retrieveLogsRequest( + RetrieveLogsResponseCallback callback, + Integer intent, + Integer requestedProtocol, + byte[] transferFileDesignator, + int timedInvokeTimeoutMs) { + retrieveLogsRequest( + chipClusterPtr, + callback, + intent, + requestedProtocol, + transferFileDesignator, + timedInvokeTimeoutMs); + } + + private native void retrieveLogsRequest( + long chipClusterPtr, + RetrieveLogsResponseCallback Callback, + Integer intent, + Integer requestedProtocol, + byte[] transferFileDesignator, + @Nullable Integer timedInvokeTimeoutMs); - public void retrieveLogsRequest(RetrieveLogsResponseCallback callback - , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator - , int timedInvokeTimeoutMs) { - retrieveLogsRequest(chipClusterPtr, callback, intent, requestedProtocol, transferFileDesignator, timedInvokeTimeoutMs); - } - private native void retrieveLogsRequest(long chipClusterPtr, RetrieveLogsResponseCallback Callback - , Integer intent, Integer requestedProtocol, byte[] transferFileDesignator - , @Nullable Integer timedInvokeTimeoutMs); public interface RetrieveLogsResponseCallback { void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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); } public static class DoorLockCluster extends BaseChipCluster { @@ -4053,733 +4664,886 @@ public DoorLockCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - - public void clearCredential(DefaultClusterCallback callback - , @Nullable ChipStructs.DoorLockClusterDlCredential credential - , int timedInvokeTimeoutMs) { + public void clearCredential( + DefaultClusterCallback callback, + @Nullable ChipStructs.DoorLockClusterDlCredential credential, + int timedInvokeTimeoutMs) { clearCredential(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); } - - public void clearUser(DefaultClusterCallback callback - , Integer userIndex - , int timedInvokeTimeoutMs) { + public void clearUser( + DefaultClusterCallback callback, Integer userIndex, int timedInvokeTimeoutMs) { clearUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); } - public void clearWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex) { + public void clearWeekDaySchedule( + DefaultClusterCallback callback, Integer weekDayIndex, Integer userIndex) { clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); } - public void clearWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void clearWeekDaySchedule( + DefaultClusterCallback callback, + Integer weekDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { clearWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); } - public void clearYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex) { + public void clearYearDaySchedule( + DefaultClusterCallback callback, Integer yearDayIndex, Integer userIndex) { clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); } - public void clearYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void clearYearDaySchedule( + DefaultClusterCallback callback, + Integer yearDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { clearYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); } - public void getCredentialStatus(GetCredentialStatusResponseCallback callback - , ChipStructs.DoorLockClusterDlCredential credential) { + public void getCredentialStatus( + GetCredentialStatusResponseCallback callback, + ChipStructs.DoorLockClusterDlCredential credential) { getCredentialStatus(chipClusterPtr, callback, credential, null); } - public void getCredentialStatus(GetCredentialStatusResponseCallback callback - , ChipStructs.DoorLockClusterDlCredential credential - , int timedInvokeTimeoutMs) { + public void getCredentialStatus( + GetCredentialStatusResponseCallback callback, + ChipStructs.DoorLockClusterDlCredential credential, + int timedInvokeTimeoutMs) { getCredentialStatus(chipClusterPtr, callback, credential, timedInvokeTimeoutMs); } - public void getUser(GetUserResponseCallback callback - , Integer userIndex) { + public void getUser(GetUserResponseCallback callback, Integer userIndex) { getUser(chipClusterPtr, callback, userIndex, null); } - public void getUser(GetUserResponseCallback callback - , Integer userIndex - , int timedInvokeTimeoutMs) { + public void getUser( + GetUserResponseCallback callback, Integer userIndex, int timedInvokeTimeoutMs) { getUser(chipClusterPtr, callback, userIndex, timedInvokeTimeoutMs); } - public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback - , Integer weekDayIndex, Integer userIndex) { + public void getWeekDaySchedule( + GetWeekDayScheduleResponseCallback callback, Integer weekDayIndex, Integer userIndex) { getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, null); } - public void getWeekDaySchedule(GetWeekDayScheduleResponseCallback callback - , Integer weekDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void getWeekDaySchedule( + GetWeekDayScheduleResponseCallback callback, + Integer weekDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { getWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, timedInvokeTimeoutMs); } - public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback - , Integer yearDayIndex, Integer userIndex) { + public void getYearDaySchedule( + GetYearDayScheduleResponseCallback callback, Integer yearDayIndex, Integer userIndex) { getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, null); } - public void getYearDaySchedule(GetYearDayScheduleResponseCallback callback - , Integer yearDayIndex, Integer userIndex - , int timedInvokeTimeoutMs) { + public void getYearDaySchedule( + GetYearDayScheduleResponseCallback callback, + Integer yearDayIndex, + Integer userIndex, + int timedInvokeTimeoutMs) { getYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, timedInvokeTimeoutMs); } - - public void lockDoor(DefaultClusterCallback callback - , Optional pinCode - , int timedInvokeTimeoutMs) { + public void lockDoor( + DefaultClusterCallback callback, Optional pinCode, int timedInvokeTimeoutMs) { lockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); } - - public void setCredential(SetCredentialResponseCallback callback - , Integer operationType, ChipStructs.DoorLockClusterDlCredential credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType - , int timedInvokeTimeoutMs) { - setCredential(chipClusterPtr, callback, operationType, credential, credentialData, userIndex, userStatus, userType, timedInvokeTimeoutMs); - } - - - public void setUser(DefaultClusterCallback callback - , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule - , int timedInvokeTimeoutMs) { - setUser(chipClusterPtr, callback, operationType, userIndex, userName, userUniqueId, userStatus, userType, credentialRule, timedInvokeTimeoutMs); - } - - public void setWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute) { - setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, null); - } - - public void setWeekDaySchedule(DefaultClusterCallback callback - , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute - , int timedInvokeTimeoutMs) { - setWeekDaySchedule(chipClusterPtr, callback, weekDayIndex, userIndex, daysMask, startHour, startMinute, endHour, endMinute, timedInvokeTimeoutMs); - } - - public void setYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime) { - setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null); - } - - public void setYearDaySchedule(DefaultClusterCallback callback - , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime - , int timedInvokeTimeoutMs) { - setYearDaySchedule(chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, timedInvokeTimeoutMs); - } - - - public void unlockDoor(DefaultClusterCallback callback - , Optional pinCode - , int timedInvokeTimeoutMs) { + public void setCredential( + SetCredentialResponseCallback callback, + Integer operationType, + ChipStructs.DoorLockClusterDlCredential credential, + byte[] credentialData, + @Nullable Integer userIndex, + @Nullable Integer userStatus, + @Nullable Integer userType, + int timedInvokeTimeoutMs) { + setCredential( + chipClusterPtr, + callback, + operationType, + credential, + credentialData, + userIndex, + userStatus, + userType, + timedInvokeTimeoutMs); + } + + public void setUser( + DefaultClusterCallback callback, + Integer operationType, + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + int timedInvokeTimeoutMs) { + setUser( + chipClusterPtr, + callback, + operationType, + userIndex, + userName, + userUniqueId, + userStatus, + userType, + credentialRule, + timedInvokeTimeoutMs); + } + + public void setWeekDaySchedule( + DefaultClusterCallback callback, + Integer weekDayIndex, + Integer userIndex, + Integer daysMask, + Integer startHour, + Integer startMinute, + Integer endHour, + Integer endMinute) { + setWeekDaySchedule( + chipClusterPtr, + callback, + weekDayIndex, + userIndex, + daysMask, + startHour, + startMinute, + endHour, + endMinute, + null); + } + + public void setWeekDaySchedule( + DefaultClusterCallback callback, + Integer weekDayIndex, + Integer userIndex, + Integer daysMask, + Integer startHour, + Integer startMinute, + Integer endHour, + Integer endMinute, + int timedInvokeTimeoutMs) { + setWeekDaySchedule( + chipClusterPtr, + callback, + weekDayIndex, + userIndex, + daysMask, + startHour, + startMinute, + endHour, + endMinute, + timedInvokeTimeoutMs); + } + + public void setYearDaySchedule( + DefaultClusterCallback callback, + Integer yearDayIndex, + Integer userIndex, + Long localStartTime, + Long localEndTime) { + setYearDaySchedule( + chipClusterPtr, callback, yearDayIndex, userIndex, localStartTime, localEndTime, null); + } + + public void setYearDaySchedule( + DefaultClusterCallback callback, + Integer yearDayIndex, + Integer userIndex, + Long localStartTime, + Long localEndTime, + int timedInvokeTimeoutMs) { + setYearDaySchedule( + chipClusterPtr, + callback, + yearDayIndex, + userIndex, + localStartTime, + localEndTime, + timedInvokeTimeoutMs); + } + + public void unlockDoor( + DefaultClusterCallback callback, Optional pinCode, int timedInvokeTimeoutMs) { unlockDoor(chipClusterPtr, callback, pinCode, timedInvokeTimeoutMs); } - - public void unlockWithTimeout(DefaultClusterCallback callback - , Integer timeout, Optional pinCode - , int timedInvokeTimeoutMs) { + public void unlockWithTimeout( + DefaultClusterCallback callback, + Integer timeout, + Optional pinCode, + int timedInvokeTimeoutMs) { unlockWithTimeout(chipClusterPtr, callback, timeout, pinCode, timedInvokeTimeoutMs); } - private native void clearCredential(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable ChipStructs.DoorLockClusterDlCredential credential - , @Nullable Integer timedInvokeTimeoutMs); - private native void clearUser(long chipClusterPtr, DefaultClusterCallback Callback - , Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void clearWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer weekDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void clearYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer yearDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void getCredentialStatus(long chipClusterPtr, GetCredentialStatusResponseCallback Callback - , ChipStructs.DoorLockClusterDlCredential credential - , @Nullable Integer timedInvokeTimeoutMs); - private native void getUser(long chipClusterPtr, GetUserResponseCallback Callback - , Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void getWeekDaySchedule(long chipClusterPtr, GetWeekDayScheduleResponseCallback Callback - , Integer weekDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void getYearDaySchedule(long chipClusterPtr, GetYearDayScheduleResponseCallback Callback - , Integer yearDayIndex, Integer userIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void lockDoor(long chipClusterPtr, DefaultClusterCallback Callback - , Optional pinCode - , @Nullable Integer timedInvokeTimeoutMs); - private native void setCredential(long chipClusterPtr, SetCredentialResponseCallback Callback - , Integer operationType, ChipStructs.DoorLockClusterDlCredential credential, byte[] credentialData, @Nullable Integer userIndex, @Nullable Integer userStatus, @Nullable Integer userType - , @Nullable Integer timedInvokeTimeoutMs); - private native void setUser(long chipClusterPtr, DefaultClusterCallback Callback - , Integer operationType, Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule - , @Nullable Integer timedInvokeTimeoutMs); - private native void setWeekDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer weekDayIndex, Integer userIndex, Integer daysMask, Integer startHour, Integer startMinute, Integer endHour, Integer endMinute - , @Nullable Integer timedInvokeTimeoutMs); - private native void setYearDaySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer yearDayIndex, Integer userIndex, Long localStartTime, Long localEndTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void unlockDoor(long chipClusterPtr, DefaultClusterCallback Callback - , Optional pinCode - , @Nullable Integer timedInvokeTimeoutMs); - private native void unlockWithTimeout(long chipClusterPtr, DefaultClusterCallback Callback - , Integer timeout, Optional pinCode - , @Nullable Integer timedInvokeTimeoutMs); + + private native void clearCredential( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable ChipStructs.DoorLockClusterDlCredential credential, + @Nullable Integer timedInvokeTimeoutMs); + + private native void clearUser( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void clearWeekDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer weekDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void clearYearDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer yearDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getCredentialStatus( + long chipClusterPtr, + GetCredentialStatusResponseCallback Callback, + ChipStructs.DoorLockClusterDlCredential credential, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getUser( + long chipClusterPtr, + GetUserResponseCallback Callback, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getWeekDaySchedule( + long chipClusterPtr, + GetWeekDayScheduleResponseCallback Callback, + Integer weekDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getYearDaySchedule( + long chipClusterPtr, + GetYearDayScheduleResponseCallback Callback, + Integer yearDayIndex, + Integer userIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void lockDoor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Optional pinCode, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setCredential( + long chipClusterPtr, + SetCredentialResponseCallback Callback, + Integer operationType, + ChipStructs.DoorLockClusterDlCredential credential, + byte[] credentialData, + @Nullable Integer userIndex, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setUser( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer operationType, + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setWeekDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer weekDayIndex, + Integer userIndex, + Integer daysMask, + Integer startHour, + Integer startMinute, + Integer endHour, + Integer endMinute, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setYearDaySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer yearDayIndex, + Integer userIndex, + Long localStartTime, + Long localEndTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void unlockDoor( + long chipClusterPtr, + DefaultClusterCallback Callback, + Optional pinCode, + @Nullable Integer timedInvokeTimeoutMs); + + private native void unlockWithTimeout( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer timeout, + Optional pinCode, + @Nullable Integer timedInvokeTimeoutMs); + public interface GetCredentialStatusResponseCallback { - void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); + void onSuccess( + Boolean credentialExists, + @Nullable Integer userIndex, + @Nullable Integer nextCredentialIndex); void onError(Exception error); } public interface GetUserResponseCallback { - void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex); + void onSuccess( + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + @Nullable ArrayList credentials, + @Nullable Integer creatorFabricIndex, + @Nullable Integer lastModifiedFabricIndex, + @Nullable Integer nextUserIndex); void onError(Exception error); } public interface GetWeekDayScheduleResponseCallback { - void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute); + void onSuccess( + Integer weekDayIndex, + Integer userIndex, + Integer status, + Optional daysMask, + Optional startHour, + Optional startMinute, + Optional endHour, + Optional endMinute); void onError(Exception error); } public interface GetYearDayScheduleResponseCallback { - void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime); + void onSuccess( + Integer yearDayIndex, + Integer userIndex, + Integer status, + Optional localStartTime, + Optional localEndTime); void onError(Exception error); } public interface SetCredentialResponseCallback { - void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); + void onSuccess( + Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex); void onError(Exception error); } + public interface LockStateAttributeCallback { + void onSuccess(@Nullable Integer value); - public interface LockStateAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface DoorStateAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); - public void readLockStateAttribute( - LockStateAttributeCallback callback - ) { - readLockStateAttribute(chipClusterPtr, callback); + default void onSubscriptionEstablished() {} } - public void subscribeLockStateAttribute( - LockStateAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeLockStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + + public interface DoorStateAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void readLockTypeAttribute( - IntegerAttributeCallback callback - ) { - readLockTypeAttribute(chipClusterPtr, callback); + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } + + public void readLockStateAttribute(LockStateAttributeCallback callback) { + readLockStateAttribute(chipClusterPtr, callback); + } + + public void subscribeLockStateAttribute( + LockStateAttributeCallback callback, int minInterval, int maxInterval) { + subscribeLockStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readLockTypeAttribute(IntegerAttributeCallback callback) { + readLockTypeAttribute(chipClusterPtr, callback); + } + public void subscribeLockTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLockTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActuatorEnabledAttribute( - BooleanAttributeCallback callback - ) { + public void readActuatorEnabledAttribute(BooleanAttributeCallback callback) { readActuatorEnabledAttribute(chipClusterPtr, callback); } + public void subscribeActuatorEnabledAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeActuatorEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDoorStateAttribute( - DoorStateAttributeCallback callback - ) { + public void readDoorStateAttribute(DoorStateAttributeCallback callback) { readDoorStateAttribute(chipClusterPtr, callback); } + public void subscribeDoorStateAttribute( - DoorStateAttributeCallback callback - , - int minInterval, int maxInterval) { + DoorStateAttributeCallback callback, int minInterval, int maxInterval) { subscribeDoorStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfTotalUsersSupportedAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfTotalUsersSupportedAttribute(IntegerAttributeCallback callback) { readNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfTotalUsersSupportedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfTotalUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfTotalUsersSupportedAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfPINUsersSupportedAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfPINUsersSupportedAttribute(IntegerAttributeCallback callback) { readNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfPINUsersSupportedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfPINUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfPINUsersSupportedAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfRFIDUsersSupportedAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfRFIDUsersSupportedAttribute(IntegerAttributeCallback callback) { readNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfRFIDUsersSupportedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfRFIDUsersSupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfRFIDUsersSupportedAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNumberOfWeekDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback - ) { + IntegerAttributeCallback callback) { readNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNumberOfYearDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback - ) { + IntegerAttributeCallback callback) { readNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxPINCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxPINCodeLengthAttribute(IntegerAttributeCallback callback) { readMaxPINCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMaxPINCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinPINCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMinPINCodeLengthAttribute(IntegerAttributeCallback callback) { readMinPINCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMinPINCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinPINCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxRFIDCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxRFIDCodeLengthAttribute(IntegerAttributeCallback callback) { readMaxRFIDCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMaxRFIDCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinRFIDCodeLengthAttribute( - IntegerAttributeCallback callback - ) { + public void readMinRFIDCodeLengthAttribute(IntegerAttributeCallback callback) { readMinRFIDCodeLengthAttribute(chipClusterPtr, callback); } + public void subscribeMinRFIDCodeLengthAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinRFIDCodeLengthAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLanguageAttribute( - CharStringAttributeCallback callback - ) { + public void readLanguageAttribute(CharStringAttributeCallback callback) { readLanguageAttribute(chipClusterPtr, callback); } + public void writeLanguageAttribute(DefaultClusterCallback callback, String value) { writeLanguageAttribute(chipClusterPtr, callback, value, null); } - public void writeLanguageAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLanguageAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLanguageAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLanguageAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLanguageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAutoRelockTimeAttribute( - LongAttributeCallback callback - ) { + public void readAutoRelockTimeAttribute(LongAttributeCallback callback) { readAutoRelockTimeAttribute(chipClusterPtr, callback); } + public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value) { writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeAutoRelockTimeAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeAutoRelockTimeAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeAutoRelockTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeAutoRelockTimeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeAutoRelockTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSoundVolumeAttribute( - IntegerAttributeCallback callback - ) { + public void readSoundVolumeAttribute(IntegerAttributeCallback callback) { readSoundVolumeAttribute(chipClusterPtr, callback); } + public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value) { writeSoundVolumeAttribute(chipClusterPtr, callback, value, null); } - public void writeSoundVolumeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSoundVolumeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSoundVolumeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeSoundVolumeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSoundVolumeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperatingModeAttribute( - IntegerAttributeCallback callback - ) { + public void readOperatingModeAttribute(IntegerAttributeCallback callback) { readOperatingModeAttribute(chipClusterPtr, callback); } + public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value) { writeOperatingModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOperatingModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOperatingModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOperatingModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOperatingModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOperatingModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedOperatingModesAttribute( - IntegerAttributeCallback callback - ) { + public void readSupportedOperatingModesAttribute(IntegerAttributeCallback callback) { readSupportedOperatingModesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedOperatingModesAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedOperatingModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnableOneTouchLockingAttribute( - BooleanAttributeCallback callback - ) { + public void readEnableOneTouchLockingAttribute(BooleanAttributeCallback callback) { readEnableOneTouchLockingAttribute(chipClusterPtr, callback); } - public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value) { + + public void writeEnableOneTouchLockingAttribute( + DefaultClusterCallback callback, Boolean value) { writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, null); } - public void writeEnableOneTouchLockingAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeEnableOneTouchLockingAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeEnableOneTouchLockingAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnableOneTouchLockingAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnableOneTouchLockingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnablePrivacyModeButtonAttribute( - BooleanAttributeCallback callback - ) { + public void readEnablePrivacyModeButtonAttribute(BooleanAttributeCallback callback) { readEnablePrivacyModeButtonAttribute(chipClusterPtr, callback); } - public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value) { + + public void writeEnablePrivacyModeButtonAttribute( + DefaultClusterCallback callback, Boolean value) { writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, null); } - public void writeEnablePrivacyModeButtonAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeEnablePrivacyModeButtonAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnablePrivacyModeButtonAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnablePrivacyModeButtonAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWrongCodeEntryLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readWrongCodeEntryLimitAttribute(IntegerAttributeCallback callback) { readWrongCodeEntryLimitAttribute(chipClusterPtr, callback); } + public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value) { writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeWrongCodeEntryLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeWrongCodeEntryLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeWrongCodeEntryLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWrongCodeEntryLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLockStateAttribute(long chipClusterPtr, - LockStateAttributeCallback callback - ); - private native void subscribeLockStateAttribute(long chipClusterPtr, - LockStateAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readLockTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLockTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActuatorEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeActuatorEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDoorStateAttribute(long chipClusterPtr, - DoorStateAttributeCallback callback - ); - private native void subscribeDoorStateAttribute(long chipClusterPtr, - DoorStateAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfTotalUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfPINUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfPINUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfRFIDUsersSupportedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinPINCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinRFIDCodeLengthAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLanguageAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeLanguageAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLanguageAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAutoRelockTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeAutoRelockTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeAutoRelockTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSoundVolumeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeSoundVolumeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSoundVolumeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOperatingModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOperatingModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOperatingModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedOperatingModesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSupportedOperatingModesAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnableOneTouchLockingAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeEnableOneTouchLockingAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnableOneTouchLockingAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnablePrivacyModeButtonAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeEnablePrivacyModeButtonAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnablePrivacyModeButtonAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWrongCodeEntryLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeWrongCodeEntryLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeWrongCodeEntryLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readLockStateAttribute( + long chipClusterPtr, LockStateAttributeCallback callback); + + private native void subscribeLockStateAttribute( + long chipClusterPtr, LockStateAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLockTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLockTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActuatorEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeActuatorEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDoorStateAttribute( + long chipClusterPtr, DoorStateAttributeCallback callback); + + private native void subscribeDoorStateAttribute( + long chipClusterPtr, DoorStateAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfTotalUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfTotalUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfPINUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfPINUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfRFIDUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfRFIDUsersSupportedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfWeekDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfWeekDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfYearDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfYearDaySchedulesSupportedPerUserAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinPINCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinRFIDCodeLengthAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLanguageAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeLanguageAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLanguageAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readAutoRelockTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void writeAutoRelockTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeAutoRelockTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSoundVolumeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeSoundVolumeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSoundVolumeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOperatingModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOperatingModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOperatingModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSupportedOperatingModesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSupportedOperatingModesAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnableOneTouchLockingAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeEnableOneTouchLockingAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnableOneTouchLockingAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnablePrivacyModeButtonAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeEnablePrivacyModeButtonAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnablePrivacyModeButtonAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWrongCodeEntryLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeWrongCodeEntryLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeWrongCodeEntryLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ElectricalMeasurementCluster extends BaseChipCluster { @@ -4792,258 +5556,211 @@ public ElectricalMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readMeasurementTypeAttribute( - LongAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMeasurementTypeAttribute(LongAttributeCallback callback) { readMeasurementTypeAttribute(chipClusterPtr, callback); } + public void subscribeMeasurementTypeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasurementTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTotalActivePowerAttribute( - LongAttributeCallback callback - ) { + public void readTotalActivePowerAttribute(LongAttributeCallback callback) { readTotalActivePowerAttribute(chipClusterPtr, callback); } + public void subscribeTotalActivePowerAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTotalActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsVoltageAttribute(IntegerAttributeCallback callback) { readRmsVoltageAttribute(chipClusterPtr, callback); } + public void subscribeRmsVoltageAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageMinAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsVoltageMinAttribute(IntegerAttributeCallback callback) { readRmsVoltageMinAttribute(chipClusterPtr, callback); } + public void subscribeRmsVoltageMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsVoltageMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsVoltageMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsVoltageMaxAttribute(IntegerAttributeCallback callback) { readRmsVoltageMaxAttribute(chipClusterPtr, callback); } + public void subscribeRmsVoltageMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsVoltageMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsCurrentAttribute(IntegerAttributeCallback callback) { readRmsCurrentAttribute(chipClusterPtr, callback); } + public void subscribeRmsCurrentAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsCurrentAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentMinAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsCurrentMinAttribute(IntegerAttributeCallback callback) { readRmsCurrentMinAttribute(chipClusterPtr, callback); } + public void subscribeRmsCurrentMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsCurrentMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRmsCurrentMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readRmsCurrentMaxAttribute(IntegerAttributeCallback callback) { readRmsCurrentMaxAttribute(chipClusterPtr, callback); } + public void subscribeRmsCurrentMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRmsCurrentMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerAttribute( - IntegerAttributeCallback callback - ) { + public void readActivePowerAttribute(IntegerAttributeCallback callback) { readActivePowerAttribute(chipClusterPtr, callback); } + public void subscribeActivePowerAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActivePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerMinAttribute( - IntegerAttributeCallback callback - ) { + public void readActivePowerMinAttribute(IntegerAttributeCallback callback) { readActivePowerMinAttribute(chipClusterPtr, callback); } + public void subscribeActivePowerMinAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActivePowerMinAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActivePowerMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readActivePowerMaxAttribute(IntegerAttributeCallback callback) { readActivePowerMaxAttribute(chipClusterPtr, callback); } + public void subscribeActivePowerMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActivePowerMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasurementTypeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeMeasurementTypeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTotalActivePowerAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTotalActivePowerAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsVoltageAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsVoltageAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsVoltageMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsVoltageMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsVoltageMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsVoltageMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsCurrentAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsCurrentAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsCurrentMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsCurrentMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRmsCurrentMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRmsCurrentMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActivePowerAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeActivePowerAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActivePowerMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeActivePowerMinAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActivePowerMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeActivePowerMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasurementTypeAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeMeasurementTypeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTotalActivePowerAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTotalActivePowerAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsVoltageAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsVoltageAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsVoltageMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsVoltageMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsVoltageMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsVoltageMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsCurrentAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsCurrentAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsCurrentMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsCurrentMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRmsCurrentMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRmsCurrentMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActivePowerAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeActivePowerAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActivePowerMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeActivePowerMinAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActivePowerMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeActivePowerMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class EthernetNetworkDiagnosticsCluster extends BaseChipCluster { @@ -5056,253 +5773,210 @@ public EthernetNetworkDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetCounts(DefaultClusterCallback callback - ) { + public void resetCounts(DefaultClusterCallback callback) { resetCounts(chipClusterPtr, callback, null); } - public void resetCounts(DefaultClusterCallback callback + public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void resetCounts( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readPHYRateAttribute( - IntegerAttributeCallback callback - ) { + public void readPHYRateAttribute(IntegerAttributeCallback callback) { readPHYRateAttribute(chipClusterPtr, callback); } + public void subscribePHYRateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePHYRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFullDuplexAttribute( - BooleanAttributeCallback callback - ) { + public void readFullDuplexAttribute(BooleanAttributeCallback callback) { readFullDuplexAttribute(chipClusterPtr, callback); } + public void subscribeFullDuplexAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeFullDuplexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketRxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketRxCountAttribute(LongAttributeCallback callback) { readPacketRxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketTxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketTxCountAttribute(LongAttributeCallback callback) { readPacketTxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketTxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrCountAttribute(LongAttributeCallback callback) { readTxErrCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCollisionCountAttribute( - LongAttributeCallback callback - ) { + public void readCollisionCountAttribute(LongAttributeCallback callback) { readCollisionCountAttribute(chipClusterPtr, callback); } + public void subscribeCollisionCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCollisionCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute( - LongAttributeCallback callback - ) { + public void readOverrunCountAttribute(LongAttributeCallback callback) { readOverrunCountAttribute(chipClusterPtr, callback); } + public void subscribeOverrunCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCarrierDetectAttribute( - BooleanAttributeCallback callback - ) { + public void readCarrierDetectAttribute(BooleanAttributeCallback callback) { readCarrierDetectAttribute(chipClusterPtr, callback); } + public void subscribeCarrierDetectAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeCarrierDetectAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTimeSinceResetAttribute( - LongAttributeCallback callback - ) { + public void readTimeSinceResetAttribute(LongAttributeCallback callback) { readTimeSinceResetAttribute(chipClusterPtr, callback); } + public void subscribeTimeSinceResetAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTimeSinceResetAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readPHYRateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePHYRateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readFullDuplexAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeFullDuplexAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCollisionCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCollisionCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCarrierDetectAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeCarrierDetectAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTimeSinceResetAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTimeSinceResetAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readPHYRateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePHYRateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFullDuplexAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeFullDuplexAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCollisionCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCollisionCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCarrierDetectAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeCarrierDetectAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTimeSinceResetAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTimeSinceResetAttribute( + long chipClusterPtr, LongAttributeCallback 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 FixedLabelCluster extends BaseChipCluster { @@ -5315,73 +5989,69 @@ public FixedLabelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LabelListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface LabelListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readLabelListAttribute( - LabelListAttributeCallback callback - ) { + public void readLabelListAttribute(LabelListAttributeCallback callback) { readLabelListAttribute(chipClusterPtr, callback); } + public void subscribeLabelListAttribute( - LabelListAttributeCallback callback - , - int minInterval, int maxInterval) { + LabelListAttributeCallback callback, int minInterval, int maxInterval) { subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback callback - ); - private native void subscribeLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback callback); + + private native void subscribeLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class FlowMeasurementCluster extends BaseChipCluster { @@ -5394,125 +6064,106 @@ public FlowMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { + public void readToleranceAttribute(IntegerAttributeCallback callback) { readToleranceAttribute(chipClusterPtr, callback); } + public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GeneralCommissioningCluster extends BaseChipCluster { @@ -5525,47 +6176,88 @@ public GeneralCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void armFailSafe(ArmFailSafeResponseCallback callback - , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs) { + public void armFailSafe( + ArmFailSafeResponseCallback callback, + Integer expiryLengthSeconds, + Long breadcrumb, + Long timeoutMs) { armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timeoutMs, null); } - public void armFailSafe(ArmFailSafeResponseCallback callback - , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs - , int timedInvokeTimeoutMs) { - armFailSafe(chipClusterPtr, callback, expiryLengthSeconds, breadcrumb, timeoutMs, timedInvokeTimeoutMs); + public void armFailSafe( + ArmFailSafeResponseCallback callback, + Integer expiryLengthSeconds, + Long breadcrumb, + Long timeoutMs, + int timedInvokeTimeoutMs) { + armFailSafe( + chipClusterPtr, + callback, + expiryLengthSeconds, + breadcrumb, + timeoutMs, + timedInvokeTimeoutMs); } - public void commissioningComplete(CommissioningCompleteResponseCallback callback - ) { + public void commissioningComplete(CommissioningCompleteResponseCallback callback) { commissioningComplete(chipClusterPtr, callback, null); } - public void commissioningComplete(CommissioningCompleteResponseCallback callback + public void commissioningComplete( + CommissioningCompleteResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { commissioningComplete(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback - , Integer location, String countryCode, Long breadcrumb, Long timeoutMs) { - setRegulatoryConfig(chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, null); - } - - public void setRegulatoryConfig(SetRegulatoryConfigResponseCallback callback - , Integer location, String countryCode, Long breadcrumb, Long timeoutMs - , int timedInvokeTimeoutMs) { - setRegulatoryConfig(chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, timedInvokeTimeoutMs); - } - private native void armFailSafe(long chipClusterPtr, ArmFailSafeResponseCallback Callback - , Integer expiryLengthSeconds, Long breadcrumb, Long timeoutMs - , @Nullable Integer timedInvokeTimeoutMs); - private native void commissioningComplete(long chipClusterPtr, CommissioningCompleteResponseCallback Callback + public void setRegulatoryConfig( + SetRegulatoryConfigResponseCallback callback, + Integer location, + String countryCode, + Long breadcrumb, + Long timeoutMs) { + setRegulatoryConfig( + chipClusterPtr, callback, location, countryCode, breadcrumb, timeoutMs, null); + } + + public void setRegulatoryConfig( + SetRegulatoryConfigResponseCallback callback, + Integer location, + String countryCode, + Long breadcrumb, + Long timeoutMs, + int timedInvokeTimeoutMs) { + setRegulatoryConfig( + chipClusterPtr, + callback, + location, + countryCode, + breadcrumb, + timeoutMs, + timedInvokeTimeoutMs); + } + + private native void armFailSafe( + long chipClusterPtr, + ArmFailSafeResponseCallback Callback, + Integer expiryLengthSeconds, + Long breadcrumb, + Long timeoutMs, + @Nullable Integer timedInvokeTimeoutMs); + + private native void commissioningComplete( + long chipClusterPtr, + CommissioningCompleteResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setRegulatoryConfig( + long chipClusterPtr, + SetRegulatoryConfigResponseCallback Callback, + Integer location, + String countryCode, + Long breadcrumb, + Long timeoutMs, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void setRegulatoryConfig(long chipClusterPtr, SetRegulatoryConfigResponseCallback Callback - , Integer location, String countryCode, Long breadcrumb, Long timeoutMs - , @Nullable Integer timedInvokeTimeoutMs); public interface ArmFailSafeResponseCallback { void onSuccess(Integer errorCode, String debugText); @@ -5584,140 +6276,135 @@ public interface SetRegulatoryConfigResponseCallback { void onError(Exception error); } + public interface BasicCommissioningInfoListAttributeCallback { + void onSuccess( + List valueList); - public interface BasicCommissioningInfoListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readBreadcrumbAttribute( - LongAttributeCallback callback - ) { + public void readBreadcrumbAttribute(LongAttributeCallback callback) { readBreadcrumbAttribute(chipClusterPtr, callback); } + public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value) { writeBreadcrumbAttribute(chipClusterPtr, callback, value, null); } - public void writeBreadcrumbAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBreadcrumbAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBreadcrumbAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBreadcrumbAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBreadcrumbAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readBasicCommissioningInfoListAttribute( - BasicCommissioningInfoListAttributeCallback callback - ) { + BasicCommissioningInfoListAttributeCallback callback) { readBasicCommissioningInfoListAttribute(chipClusterPtr, callback); } + public void subscribeBasicCommissioningInfoListAttribute( - BasicCommissioningInfoListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeBasicCommissioningInfoListAttribute(chipClusterPtr, callback, minInterval, maxInterval); + BasicCommissioningInfoListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeBasicCommissioningInfoListAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readRegulatoryConfigAttribute( - IntegerAttributeCallback callback - ) { + public void readRegulatoryConfigAttribute(IntegerAttributeCallback callback) { readRegulatoryConfigAttribute(chipClusterPtr, callback); } + public void subscribeRegulatoryConfigAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRegulatoryConfigAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLocationCapabilityAttribute( - IntegerAttributeCallback callback - ) { + public void readLocationCapabilityAttribute(IntegerAttributeCallback callback) { readLocationCapabilityAttribute(chipClusterPtr, callback); } + public void subscribeLocationCapabilityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocationCapabilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBreadcrumbAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeBreadcrumbAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBreadcrumbAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBasicCommissioningInfoListAttribute(long chipClusterPtr, - BasicCommissioningInfoListAttributeCallback callback - ); - private native void subscribeBasicCommissioningInfoListAttribute(long chipClusterPtr, - BasicCommissioningInfoListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readRegulatoryConfigAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRegulatoryConfigAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLocationCapabilityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLocationCapabilityAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readBreadcrumbAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void writeBreadcrumbAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBreadcrumbAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBasicCommissioningInfoListAttribute( + long chipClusterPtr, BasicCommissioningInfoListAttributeCallback callback); + + private native void subscribeBasicCommissioningInfoListAttribute( + long chipClusterPtr, + BasicCommissioningInfoListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readRegulatoryConfigAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRegulatoryConfigAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLocationCapabilityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLocationCapabilityAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GeneralDiagnosticsCluster extends BaseChipCluster { @@ -5730,221 +6417,209 @@ public GeneralDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface NetworkInterfacesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveHardwareFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveRadioFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveNetworkFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface NetworkInterfacesAttributeCallback { + void onSuccess(List valueList); - public void readNetworkInterfacesAttribute( - NetworkInterfacesAttributeCallback callback - ) { - readNetworkInterfacesAttribute(chipClusterPtr, callback); - } - public void subscribeNetworkInterfacesAttribute( - NetworkInterfacesAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + void onError(Exception ex); - public void readRebootCountAttribute( - IntegerAttributeCallback callback - ) { - readRebootCountAttribute(chipClusterPtr, callback); + default void onSubscriptionEstablished() {} } - public void subscribeRebootCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeRebootCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + + public interface ActiveHardwareFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void readUpTimeAttribute( - LongAttributeCallback callback - ) { + public interface ActiveRadioFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ActiveNetworkFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readNetworkInterfacesAttribute(NetworkInterfacesAttributeCallback callback) { + readNetworkInterfacesAttribute(chipClusterPtr, callback); + } + + public void subscribeNetworkInterfacesAttribute( + NetworkInterfacesAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNetworkInterfacesAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readRebootCountAttribute(IntegerAttributeCallback callback) { + readRebootCountAttribute(chipClusterPtr, callback); + } + + public void subscribeRebootCountAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeRebootCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readUpTimeAttribute(LongAttributeCallback callback) { readUpTimeAttribute(chipClusterPtr, callback); } + public void subscribeUpTimeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTotalOperationalHoursAttribute( - LongAttributeCallback callback - ) { + public void readTotalOperationalHoursAttribute(LongAttributeCallback callback) { readTotalOperationalHoursAttribute(chipClusterPtr, callback); } + public void subscribeTotalOperationalHoursAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTotalOperationalHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBootReasonsAttribute( - IntegerAttributeCallback callback - ) { + public void readBootReasonsAttribute(IntegerAttributeCallback callback) { readBootReasonsAttribute(chipClusterPtr, callback); } + public void subscribeBootReasonsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBootReasonsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveHardwareFaultsAttribute( - ActiveHardwareFaultsAttributeCallback callback - ) { + public void readActiveHardwareFaultsAttribute(ActiveHardwareFaultsAttributeCallback callback) { readActiveHardwareFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveHardwareFaultsAttribute( - ActiveHardwareFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveHardwareFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveHardwareFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveRadioFaultsAttribute( - ActiveRadioFaultsAttributeCallback callback - ) { + public void readActiveRadioFaultsAttribute(ActiveRadioFaultsAttributeCallback callback) { readActiveRadioFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveRadioFaultsAttribute( - ActiveRadioFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveRadioFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveRadioFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveNetworkFaultsAttribute( - ActiveNetworkFaultsAttributeCallback callback - ) { + public void readActiveNetworkFaultsAttribute(ActiveNetworkFaultsAttributeCallback callback) { readActiveNetworkFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveNetworkFaultsAttribute( - ActiveNetworkFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveNetworkFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveNetworkFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNetworkInterfacesAttribute(long chipClusterPtr, - NetworkInterfacesAttributeCallback callback - ); - private native void subscribeNetworkInterfacesAttribute(long chipClusterPtr, - NetworkInterfacesAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readRebootCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRebootCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUpTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeUpTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTotalOperationalHoursAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTotalOperationalHoursAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBootReasonsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBootReasonsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveHardwareFaultsAttribute(long chipClusterPtr, - ActiveHardwareFaultsAttributeCallback callback - ); - private native void subscribeActiveHardwareFaultsAttribute(long chipClusterPtr, - ActiveHardwareFaultsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readActiveRadioFaultsAttribute(long chipClusterPtr, - ActiveRadioFaultsAttributeCallback callback - ); - private native void subscribeActiveRadioFaultsAttribute(long chipClusterPtr, - ActiveRadioFaultsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readActiveNetworkFaultsAttribute(long chipClusterPtr, - ActiveNetworkFaultsAttributeCallback callback - ); - private native void subscribeActiveNetworkFaultsAttribute(long chipClusterPtr, - ActiveNetworkFaultsAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readNetworkInterfacesAttribute( + long chipClusterPtr, NetworkInterfacesAttributeCallback callback); + + private native void subscribeNetworkInterfacesAttribute( + long chipClusterPtr, + NetworkInterfacesAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readRebootCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRebootCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUpTimeAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeUpTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTotalOperationalHoursAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTotalOperationalHoursAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBootReasonsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBootReasonsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveHardwareFaultsAttribute( + long chipClusterPtr, ActiveHardwareFaultsAttributeCallback callback); + + private native void subscribeActiveHardwareFaultsAttribute( + long chipClusterPtr, + ActiveHardwareFaultsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readActiveRadioFaultsAttribute( + long chipClusterPtr, ActiveRadioFaultsAttributeCallback callback); + + private native void subscribeActiveRadioFaultsAttribute( + long chipClusterPtr, + ActiveRadioFaultsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readActiveNetworkFaultsAttribute( + long chipClusterPtr, ActiveNetworkFaultsAttributeCallback callback); + + private native void subscribeActiveNetworkFaultsAttribute( + long chipClusterPtr, + ActiveNetworkFaultsAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GroupKeyManagementCluster extends BaseChipCluster { @@ -5957,61 +6632,73 @@ public GroupKeyManagementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void keySetRead(KeySetReadResponseCallback callback - , Integer groupKeySetID) { + public void keySetRead(KeySetReadResponseCallback callback, Integer groupKeySetID) { keySetRead(chipClusterPtr, callback, groupKeySetID, null); } - public void keySetRead(KeySetReadResponseCallback callback - , Integer groupKeySetID - , int timedInvokeTimeoutMs) { + public void keySetRead( + KeySetReadResponseCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) { keySetRead(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); } - public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback - , ArrayList groupKeySetIDs) { + public void keySetReadAllIndices( + KeySetReadAllIndicesResponseCallback callback, ArrayList groupKeySetIDs) { keySetReadAllIndices(chipClusterPtr, callback, groupKeySetIDs, null); } - public void keySetReadAllIndices(KeySetReadAllIndicesResponseCallback callback - , ArrayList groupKeySetIDs - , int timedInvokeTimeoutMs) { + public void keySetReadAllIndices( + KeySetReadAllIndicesResponseCallback callback, + ArrayList groupKeySetIDs, + int timedInvokeTimeoutMs) { keySetReadAllIndices(chipClusterPtr, callback, groupKeySetIDs, timedInvokeTimeoutMs); } - public void keySetRemove(DefaultClusterCallback callback - , Integer groupKeySetID) { + public void keySetRemove(DefaultClusterCallback callback, Integer groupKeySetID) { keySetRemove(chipClusterPtr, callback, groupKeySetID, null); } - public void keySetRemove(DefaultClusterCallback callback - , Integer groupKeySetID - , int timedInvokeTimeoutMs) { + public void keySetRemove( + DefaultClusterCallback callback, Integer groupKeySetID, int timedInvokeTimeoutMs) { keySetRemove(chipClusterPtr, callback, groupKeySetID, timedInvokeTimeoutMs); } - public void keySetWrite(DefaultClusterCallback callback - , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { + public void keySetWrite( + DefaultClusterCallback callback, + ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { keySetWrite(chipClusterPtr, callback, groupKeySet, null); } - public void keySetWrite(DefaultClusterCallback callback - , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet - , int timedInvokeTimeoutMs) { + public void keySetWrite( + DefaultClusterCallback callback, + ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet, + int timedInvokeTimeoutMs) { keySetWrite(chipClusterPtr, callback, groupKeySet, timedInvokeTimeoutMs); } - private native void keySetRead(long chipClusterPtr, KeySetReadResponseCallback Callback - , Integer groupKeySetID - , @Nullable Integer timedInvokeTimeoutMs); - private native void keySetReadAllIndices(long chipClusterPtr, KeySetReadAllIndicesResponseCallback Callback - , ArrayList groupKeySetIDs - , @Nullable Integer timedInvokeTimeoutMs); - private native void keySetRemove(long chipClusterPtr, DefaultClusterCallback Callback - , Integer groupKeySetID - , @Nullable Integer timedInvokeTimeoutMs); - private native void keySetWrite(long chipClusterPtr, DefaultClusterCallback Callback - , ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet - , @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetRead( + long chipClusterPtr, + KeySetReadResponseCallback Callback, + Integer groupKeySetID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetReadAllIndices( + long chipClusterPtr, + KeySetReadAllIndicesResponseCallback Callback, + ArrayList groupKeySetIDs, + @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetRemove( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer groupKeySetID, + @Nullable Integer timedInvokeTimeoutMs); + + private native void keySetWrite( + long chipClusterPtr, + DefaultClusterCallback Callback, + ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet, + @Nullable Integer timedInvokeTimeoutMs); + public interface KeySetReadAllIndicesResponseCallback { void onSuccess(ArrayList groupKeySetIDs); @@ -6024,136 +6711,128 @@ public interface KeySetReadResponseCallback { void onError(Exception error); } + public interface GroupKeyMapAttributeCallback { + void onSuccess(List valueList); - public interface GroupKeyMapAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface GroupTableAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface GroupTableAttributeCallback { + void onSuccess(List valueList); - public void readGroupKeyMapAttribute( - GroupKeyMapAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readGroupKeyMapAttribute(GroupKeyMapAttributeCallback callback) { readGroupKeyMapAttribute(chipClusterPtr, callback); } + public void subscribeGroupKeyMapAttribute( - GroupKeyMapAttributeCallback callback - , - int minInterval, int maxInterval) { + GroupKeyMapAttributeCallback callback, int minInterval, int maxInterval) { subscribeGroupKeyMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGroupTableAttribute( - GroupTableAttributeCallback callback - ) { + public void readGroupTableAttribute(GroupTableAttributeCallback callback) { readGroupTableAttribute(chipClusterPtr, callback); } + public void subscribeGroupTableAttribute( - GroupTableAttributeCallback callback - , - int minInterval, int maxInterval) { + GroupTableAttributeCallback callback, int minInterval, int maxInterval) { subscribeGroupTableAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxGroupsPerFabricAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxGroupsPerFabricAttribute(IntegerAttributeCallback callback) { readMaxGroupsPerFabricAttribute(chipClusterPtr, callback); } + public void subscribeMaxGroupsPerFabricAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxGroupsPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxGroupKeysPerFabricAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxGroupKeysPerFabricAttribute(IntegerAttributeCallback callback) { readMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback); } + public void subscribeMaxGroupKeysPerFabricAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxGroupKeysPerFabricAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readGroupKeyMapAttribute(long chipClusterPtr, - GroupKeyMapAttributeCallback callback - ); - private native void subscribeGroupKeyMapAttribute(long chipClusterPtr, - GroupKeyMapAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readGroupTableAttribute(long chipClusterPtr, - GroupTableAttributeCallback callback - ); - private native void subscribeGroupTableAttribute(long chipClusterPtr, - GroupTableAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readMaxGroupsPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxGroupsPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxGroupKeysPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxGroupKeysPerFabricAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readGroupKeyMapAttribute( + long chipClusterPtr, GroupKeyMapAttributeCallback callback); + + private native void subscribeGroupKeyMapAttribute( + long chipClusterPtr, + GroupKeyMapAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readGroupTableAttribute( + long chipClusterPtr, GroupTableAttributeCallback callback); + + private native void subscribeGroupTableAttribute( + long chipClusterPtr, + GroupTableAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readMaxGroupsPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxGroupsPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxGroupKeysPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxGroupKeysPerFabricAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class GroupsCluster extends BaseChipCluster { @@ -6166,89 +6845,107 @@ public GroupsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addGroup(AddGroupResponseCallback callback - , Integer groupId, String groupName) { + public void addGroup(AddGroupResponseCallback callback, Integer groupId, String groupName) { addGroup(chipClusterPtr, callback, groupId, groupName, null); } - public void addGroup(AddGroupResponseCallback callback - , Integer groupId, String groupName - , int timedInvokeTimeoutMs) { + public void addGroup( + AddGroupResponseCallback callback, + Integer groupId, + String groupName, + int timedInvokeTimeoutMs) { addGroup(chipClusterPtr, callback, groupId, groupName, timedInvokeTimeoutMs); } - public void addGroupIfIdentifying(DefaultClusterCallback callback - , Integer groupId, String groupName) { + public void addGroupIfIdentifying( + DefaultClusterCallback callback, Integer groupId, String groupName) { addGroupIfIdentifying(chipClusterPtr, callback, groupId, groupName, null); } - public void addGroupIfIdentifying(DefaultClusterCallback callback - , Integer groupId, String groupName - , int timedInvokeTimeoutMs) { + public void addGroupIfIdentifying( + DefaultClusterCallback callback, + Integer groupId, + String groupName, + int timedInvokeTimeoutMs) { addGroupIfIdentifying(chipClusterPtr, callback, groupId, groupName, timedInvokeTimeoutMs); } - public void getGroupMembership(GetGroupMembershipResponseCallback callback - , ArrayList groupList) { + public void getGroupMembership( + GetGroupMembershipResponseCallback callback, ArrayList groupList) { getGroupMembership(chipClusterPtr, callback, groupList, null); } - public void getGroupMembership(GetGroupMembershipResponseCallback callback - , ArrayList groupList - , int timedInvokeTimeoutMs) { + public void getGroupMembership( + GetGroupMembershipResponseCallback callback, + ArrayList groupList, + int timedInvokeTimeoutMs) { getGroupMembership(chipClusterPtr, callback, groupList, timedInvokeTimeoutMs); } - public void removeAllGroups(DefaultClusterCallback callback - ) { + public void removeAllGroups(DefaultClusterCallback callback) { removeAllGroups(chipClusterPtr, callback, null); } - public void removeAllGroups(DefaultClusterCallback callback + public void removeAllGroups(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { removeAllGroups(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void removeGroup(RemoveGroupResponseCallback callback - , Integer groupId) { + public void removeGroup(RemoveGroupResponseCallback callback, Integer groupId) { removeGroup(chipClusterPtr, callback, groupId, null); } - public void removeGroup(RemoveGroupResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void removeGroup( + RemoveGroupResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { removeGroup(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void viewGroup(ViewGroupResponseCallback callback - , Integer groupId) { + public void viewGroup(ViewGroupResponseCallback callback, Integer groupId) { viewGroup(chipClusterPtr, callback, groupId, null); } - public void viewGroup(ViewGroupResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void viewGroup( + ViewGroupResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { viewGroup(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - private native void addGroup(long chipClusterPtr, AddGroupResponseCallback Callback - , Integer groupId, String groupName - , @Nullable Integer timedInvokeTimeoutMs); - private native void addGroupIfIdentifying(long chipClusterPtr, DefaultClusterCallback Callback - , Integer groupId, String groupName - , @Nullable Integer timedInvokeTimeoutMs); - private native void getGroupMembership(long chipClusterPtr, GetGroupMembershipResponseCallback Callback - , ArrayList groupList - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeAllGroups(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeGroup(long chipClusterPtr, RemoveGroupResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); - private native void viewGroup(long chipClusterPtr, ViewGroupResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addGroup( + long chipClusterPtr, + AddGroupResponseCallback Callback, + Integer groupId, + String groupName, + @Nullable Integer timedInvokeTimeoutMs); + + private native void addGroupIfIdentifying( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer groupId, + String groupName, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getGroupMembership( + long chipClusterPtr, + GetGroupMembershipResponseCallback Callback, + ArrayList groupList, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeAllGroups( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeGroup( + long chipClusterPtr, + RemoveGroupResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void viewGroup( + long chipClusterPtr, + ViewGroupResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + public interface AddGroupResponseCallback { void onSuccess(Integer status, Integer groupId); @@ -6273,69 +6970,61 @@ public interface ViewGroupResponseCallback { void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readNameSupportAttribute( - IntegerAttributeCallback callback - ) { + public void readNameSupportAttribute(IntegerAttributeCallback callback) { readNameSupportAttribute(chipClusterPtr, callback); } + public void subscribeNameSupportAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class IdentifyCluster extends BaseChipCluster { @@ -6348,144 +7037,147 @@ public IdentifyCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void identify(DefaultClusterCallback callback - , Integer identifyTime) { + public void identify(DefaultClusterCallback callback, Integer identifyTime) { identify(chipClusterPtr, callback, identifyTime, null); } - public void identify(DefaultClusterCallback callback - , Integer identifyTime - , int timedInvokeTimeoutMs) { + public void identify( + DefaultClusterCallback callback, Integer identifyTime, int timedInvokeTimeoutMs) { identify(chipClusterPtr, callback, identifyTime, timedInvokeTimeoutMs); } - public void identifyQuery(IdentifyQueryResponseCallback callback - ) { + public void identifyQuery(IdentifyQueryResponseCallback callback) { identifyQuery(chipClusterPtr, callback, null); } - public void identifyQuery(IdentifyQueryResponseCallback callback + public void identifyQuery(IdentifyQueryResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { identifyQuery(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void triggerEffect(DefaultClusterCallback callback - , Integer effectIdentifier, Integer effectVariant) { + public void triggerEffect( + DefaultClusterCallback callback, Integer effectIdentifier, Integer effectVariant) { triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, null); } - public void triggerEffect(DefaultClusterCallback callback - , Integer effectIdentifier, Integer effectVariant - , int timedInvokeTimeoutMs) { - triggerEffect(chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); + public void triggerEffect( + DefaultClusterCallback callback, + Integer effectIdentifier, + Integer effectVariant, + int timedInvokeTimeoutMs) { + triggerEffect( + chipClusterPtr, callback, effectIdentifier, effectVariant, timedInvokeTimeoutMs); } - private native void identify(long chipClusterPtr, DefaultClusterCallback Callback - , Integer identifyTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void identifyQuery(long chipClusterPtr, IdentifyQueryResponseCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void triggerEffect(long chipClusterPtr, DefaultClusterCallback Callback - , Integer effectIdentifier, Integer effectVariant - , @Nullable Integer timedInvokeTimeoutMs); + private native void identify( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer identifyTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void identifyQuery( + long chipClusterPtr, + IdentifyQueryResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void triggerEffect( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer effectIdentifier, + Integer effectVariant, + @Nullable Integer timedInvokeTimeoutMs); + public interface IdentifyQueryResponseCallback { void onSuccess(Integer timeout); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readIdentifyTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readIdentifyTimeAttribute(IntegerAttributeCallback callback) { readIdentifyTimeAttribute(chipClusterPtr, callback); } + public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value) { writeIdentifyTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeIdentifyTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeIdentifyTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeIdentifyTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeIdentifyTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeIdentifyTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readIdentifyTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readIdentifyTypeAttribute(IntegerAttributeCallback callback) { readIdentifyTypeAttribute(chipClusterPtr, callback); } + public void subscribeIdentifyTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeIdentifyTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readIdentifyTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeIdentifyTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeIdentifyTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readIdentifyTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeIdentifyTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readIdentifyTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeIdentifyTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeIdentifyTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readIdentifyTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeIdentifyTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class IlluminanceMeasurementCluster extends BaseChipCluster { @@ -6498,164 +7190,165 @@ public IlluminanceMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface MeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface MinMeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface MaxMeasuredValueAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface LightSensorTypeAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface MeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readMeasuredValueAttribute( - MeasuredValueAttributeCallback callback - ) { + public interface MinMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface MaxMeasuredValueAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface LightSensorTypeAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(MeasuredValueAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - MeasuredValueAttributeCallback callback - , - int minInterval, int maxInterval) { + MeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - MinMeasuredValueAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(MinMeasuredValueAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - MinMeasuredValueAttributeCallback callback - , - int minInterval, int maxInterval) { + MinMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - MaxMeasuredValueAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(MaxMeasuredValueAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - MaxMeasuredValueAttributeCallback callback - , - int minInterval, int maxInterval) { + MaxMeasuredValueAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { + public void readToleranceAttribute(IntegerAttributeCallback callback) { readToleranceAttribute(chipClusterPtr, callback); } + public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLightSensorTypeAttribute( - LightSensorTypeAttributeCallback callback - ) { + public void readLightSensorTypeAttribute(LightSensorTypeAttributeCallback callback) { readLightSensorTypeAttribute(chipClusterPtr, callback); } + public void subscribeLightSensorTypeAttribute( - LightSensorTypeAttributeCallback callback - , - int minInterval, int maxInterval) { + LightSensorTypeAttributeCallback callback, int minInterval, int maxInterval) { subscribeLightSensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - MeasuredValueAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - MeasuredValueAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - MinMeasuredValueAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - MinMeasuredValueAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - MaxMeasuredValueAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - MaxMeasuredValueAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLightSensorTypeAttribute(long chipClusterPtr, - LightSensorTypeAttributeCallback callback - ); - private native void subscribeLightSensorTypeAttribute(long chipClusterPtr, - LightSensorTypeAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, MeasuredValueAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, + MeasuredValueAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, MinMeasuredValueAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, + MinMeasuredValueAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, MaxMeasuredValueAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, + MaxMeasuredValueAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLightSensorTypeAttribute( + long chipClusterPtr, LightSensorTypeAttributeCallback callback); + + private native void subscribeLightSensorTypeAttribute( + long chipClusterPtr, + LightSensorTypeAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class KeypadInputCluster extends BaseChipCluster { @@ -6668,69 +7361,67 @@ public KeypadInputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void sendKeyRequest(SendKeyResponseCallback callback - , Integer keyCode) { + public void sendKeyRequest(SendKeyResponseCallback callback, Integer keyCode) { sendKeyRequest(chipClusterPtr, callback, keyCode, null); } - public void sendKeyRequest(SendKeyResponseCallback callback - , Integer keyCode - , int timedInvokeTimeoutMs) { + public void sendKeyRequest( + SendKeyResponseCallback callback, Integer keyCode, int timedInvokeTimeoutMs) { sendKeyRequest(chipClusterPtr, callback, keyCode, timedInvokeTimeoutMs); } - private native void sendKeyRequest(long chipClusterPtr, SendKeyResponseCallback Callback - , Integer keyCode - , @Nullable Integer timedInvokeTimeoutMs); + + private native void sendKeyRequest( + long chipClusterPtr, + SendKeyResponseCallback Callback, + Integer keyCode, + @Nullable Integer timedInvokeTimeoutMs); + public interface SendKeyResponseCallback { void onSuccess(Integer status); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 LevelControlCluster extends BaseChipCluster { @@ -6743,617 +7434,726 @@ public LevelControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void move(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride) { + public void move( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionMask, + Integer optionOverride) { move(chipClusterPtr, callback, moveMode, rate, optionMask, optionOverride, null); } - public void move(DefaultClusterCallback callback - , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - move(chipClusterPtr, callback, moveMode, rate, optionMask, optionOverride, timedInvokeTimeoutMs); + public void move( + DefaultClusterCallback callback, + Integer moveMode, + Integer rate, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + move( + chipClusterPtr, + callback, + moveMode, + rate, + optionMask, + optionOverride, + timedInvokeTimeoutMs); + } + + public void moveToLevel( + DefaultClusterCallback callback, + Integer level, + Integer transitionTime, + Integer optionMask, + Integer optionOverride) { + moveToLevel( + chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, null); + } + + public void moveToLevel( + DefaultClusterCallback callback, + Integer level, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + moveToLevel( + chipClusterPtr, + callback, + level, + transitionTime, + optionMask, + optionOverride, + timedInvokeTimeoutMs); + } + + public void moveToLevelWithOnOff( + DefaultClusterCallback callback, Integer level, Integer transitionTime) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, null); + } + + public void moveToLevelWithOnOff( + DefaultClusterCallback callback, + Integer level, + Integer transitionTime, + int timedInvokeTimeoutMs) { + moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, timedInvokeTimeoutMs); } - public void moveToLevel(DefaultClusterCallback callback - , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride) { - moveToLevel(chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, null); + public void moveWithOnOff(DefaultClusterCallback callback, Integer moveMode, Integer rate) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, null); } - public void moveToLevel(DefaultClusterCallback callback - , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - moveToLevel(chipClusterPtr, callback, level, transitionTime, optionMask, optionOverride, timedInvokeTimeoutMs); + public void moveWithOnOff( + DefaultClusterCallback callback, Integer moveMode, Integer rate, int timedInvokeTimeoutMs) { + moveWithOnOff(chipClusterPtr, callback, moveMode, rate, timedInvokeTimeoutMs); } - public void moveToLevelWithOnOff(DefaultClusterCallback callback - , Integer level, Integer transitionTime) { - moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, null); + public void step( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionMask, + Integer optionOverride) { + step( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionMask, + optionOverride, + null); + } + + public void step( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + step( + chipClusterPtr, + callback, + stepMode, + stepSize, + transitionTime, + optionMask, + optionOverride, + timedInvokeTimeoutMs); + } + + public void stepWithOnOff( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime) { + stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, null); } - public void moveToLevelWithOnOff(DefaultClusterCallback callback - , Integer level, Integer transitionTime - , int timedInvokeTimeoutMs) { - moveToLevelWithOnOff(chipClusterPtr, callback, level, transitionTime, timedInvokeTimeoutMs); + public void stepWithOnOff( + DefaultClusterCallback callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + int timedInvokeTimeoutMs) { + stepWithOnOff( + chipClusterPtr, callback, stepMode, stepSize, transitionTime, timedInvokeTimeoutMs); } - public void moveWithOnOff(DefaultClusterCallback callback - , Integer moveMode, Integer rate) { - moveWithOnOff(chipClusterPtr, callback, moveMode, rate, null); + public void stop(DefaultClusterCallback callback, Integer optionMask, Integer optionOverride) { + stop(chipClusterPtr, callback, optionMask, optionOverride, null); } - public void moveWithOnOff(DefaultClusterCallback callback - , Integer moveMode, Integer rate - , int timedInvokeTimeoutMs) { - moveWithOnOff(chipClusterPtr, callback, moveMode, rate, timedInvokeTimeoutMs); + public void stop( + DefaultClusterCallback callback, + Integer optionMask, + Integer optionOverride, + int timedInvokeTimeoutMs) { + stop(chipClusterPtr, callback, optionMask, optionOverride, timedInvokeTimeoutMs); } - public void step(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride) { - step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionMask, optionOverride, null); + public void stopWithOnOff(DefaultClusterCallback callback) { + stopWithOnOff(chipClusterPtr, callback, null); } - public void step(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - step(chipClusterPtr, callback, stepMode, stepSize, transitionTime, optionMask, optionOverride, timedInvokeTimeoutMs); + public void stopWithOnOff(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void stepWithOnOff(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime) { - stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, null); + private native void move( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToLevel( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer level, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveToLevelWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer level, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void moveWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer moveMode, + Integer rate, + @Nullable Integer timedInvokeTimeoutMs); + + private native void step( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stepWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer stepMode, + Integer stepSize, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stop( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer optionMask, + Integer optionOverride, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopWithOnOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface OnLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stepWithOnOff(DefaultClusterCallback callback - , Integer stepMode, Integer stepSize, Integer transitionTime - , int timedInvokeTimeoutMs) { - stepWithOnOff(chipClusterPtr, callback, stepMode, stepSize, transitionTime, timedInvokeTimeoutMs); + public interface OnTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stop(DefaultClusterCallback callback - , Integer optionMask, Integer optionOverride) { - stop(chipClusterPtr, callback, optionMask, optionOverride, null); + public interface OffTransitionTimeAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stop(DefaultClusterCallback callback - , Integer optionMask, Integer optionOverride - , int timedInvokeTimeoutMs) { - stop(chipClusterPtr, callback, optionMask, optionOverride, timedInvokeTimeoutMs); + public interface DefaultMoveRateAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stopWithOnOff(DefaultClusterCallback callback - ) { - stopWithOnOff(chipClusterPtr, callback, null); + public interface StartUpCurrentLevelAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void stopWithOnOff(DefaultClusterCallback callback + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - , int timedInvokeTimeoutMs) { - stopWithOnOff(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void move(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate, Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToLevel(long chipClusterPtr, DefaultClusterCallback Callback - , Integer level, Integer transitionTime, Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveToLevelWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer level, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void moveWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer moveMode, Integer rate - , @Nullable Integer timedInvokeTimeoutMs); - private native void step(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime, Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stepWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer stepMode, Integer stepSize, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void stop(long chipClusterPtr, DefaultClusterCallback Callback - , Integer optionMask, Integer optionOverride - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopWithOnOff(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - - public interface OnLevelAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface OnTransitionTimeAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface OffTransitionTimeAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface DefaultMoveRateAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface StartUpCurrentLevelAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readCurrentLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentLevelAttribute(IntegerAttributeCallback callback) { readCurrentLevelAttribute(chipClusterPtr, callback); } + public void subscribeCurrentLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRemainingTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readRemainingTimeAttribute(IntegerAttributeCallback callback) { readRemainingTimeAttribute(chipClusterPtr, callback); } + public void subscribeRemainingTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRemainingTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readMinLevelAttribute(IntegerAttributeCallback callback) { readMinLevelAttribute(chipClusterPtr, callback); } + public void subscribeMinLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxLevelAttribute(IntegerAttributeCallback callback) { readMaxLevelAttribute(chipClusterPtr, callback); } + public void subscribeMaxLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentFrequencyAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentFrequencyAttribute(IntegerAttributeCallback callback) { readCurrentFrequencyAttribute(chipClusterPtr, callback); } + public void subscribeCurrentFrequencyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinFrequencyAttribute( - IntegerAttributeCallback callback - ) { + public void readMinFrequencyAttribute(IntegerAttributeCallback callback) { readMinFrequencyAttribute(chipClusterPtr, callback); } + public void subscribeMinFrequencyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxFrequencyAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxFrequencyAttribute(IntegerAttributeCallback callback) { readMaxFrequencyAttribute(chipClusterPtr, callback); } + public void subscribeMaxFrequencyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxFrequencyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOptionsAttribute( - IntegerAttributeCallback callback - ) { + public void readOptionsAttribute(IntegerAttributeCallback callback) { readOptionsAttribute(chipClusterPtr, callback); } + public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value) { writeOptionsAttribute(chipClusterPtr, callback, value, null); } - public void writeOptionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOptionsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOptionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOptionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOptionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnOffTransitionTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readOnOffTransitionTimeAttribute(IntegerAttributeCallback callback) { readOnOffTransitionTimeAttribute(chipClusterPtr, callback); } + public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnOffTransitionTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnOffTransitionTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnLevelAttribute( - OnLevelAttributeCallback callback - ) { + public void readOnLevelAttribute(OnLevelAttributeCallback callback) { readOnLevelAttribute(chipClusterPtr, callback); } + public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value) { writeOnLevelAttribute(chipClusterPtr, callback, value, null); } - public void writeOnLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnLevelAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnLevelAttribute( - OnLevelAttributeCallback callback - , - int minInterval, int maxInterval) { + OnLevelAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnTransitionTimeAttribute( - OnTransitionTimeAttributeCallback callback - ) { + public void readOnTransitionTimeAttribute(OnTransitionTimeAttributeCallback callback) { readOnTransitionTimeAttribute(chipClusterPtr, callback); } + public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnTransitionTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnTransitionTimeAttribute( - OnTransitionTimeAttributeCallback callback - , - int minInterval, int maxInterval) { + OnTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOffTransitionTimeAttribute( - OffTransitionTimeAttributeCallback callback - ) { + public void readOffTransitionTimeAttribute(OffTransitionTimeAttributeCallback callback) { readOffTransitionTimeAttribute(chipClusterPtr, callback); } + public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOffTransitionTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOffTransitionTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOffTransitionTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOffTransitionTimeAttribute( - OffTransitionTimeAttributeCallback callback - , - int minInterval, int maxInterval) { + OffTransitionTimeAttributeCallback callback, int minInterval, int maxInterval) { subscribeOffTransitionTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDefaultMoveRateAttribute( - DefaultMoveRateAttributeCallback callback - ) { + public void readDefaultMoveRateAttribute(DefaultMoveRateAttributeCallback callback) { readDefaultMoveRateAttribute(chipClusterPtr, callback); } + public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value) { writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, null); } - public void writeDefaultMoveRateAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeDefaultMoveRateAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeDefaultMoveRateAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeDefaultMoveRateAttribute( - DefaultMoveRateAttributeCallback callback - , - int minInterval, int maxInterval) { + DefaultMoveRateAttributeCallback callback, int minInterval, int maxInterval) { subscribeDefaultMoveRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpCurrentLevelAttribute( - StartUpCurrentLevelAttributeCallback callback - ) { + public void readStartUpCurrentLevelAttribute(StartUpCurrentLevelAttributeCallback callback) { readStartUpCurrentLevelAttribute(chipClusterPtr, callback); } + public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpCurrentLevelAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeStartUpCurrentLevelAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeStartUpCurrentLevelAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeStartUpCurrentLevelAttribute( - StartUpCurrentLevelAttributeCallback callback - , - int minInterval, int maxInterval) { + StartUpCurrentLevelAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartUpCurrentLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRemainingTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxFrequencyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOptionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOptionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOnOffTransitionTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOnOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnOffTransitionTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOnLevelAttribute(long chipClusterPtr, - OnLevelAttributeCallback callback - ); - - private native void writeOnLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnLevelAttribute(long chipClusterPtr, - OnLevelAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOnTransitionTimeAttribute(long chipClusterPtr, - OnTransitionTimeAttributeCallback callback - ); - - private native void writeOnTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnTransitionTimeAttribute(long chipClusterPtr, - OnTransitionTimeAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOffTransitionTimeAttribute(long chipClusterPtr, - OffTransitionTimeAttributeCallback callback - ); - - private native void writeOffTransitionTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOffTransitionTimeAttribute(long chipClusterPtr, - OffTransitionTimeAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readDefaultMoveRateAttribute(long chipClusterPtr, - DefaultMoveRateAttributeCallback callback - ); - - private native void writeDefaultMoveRateAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeDefaultMoveRateAttribute(long chipClusterPtr, - DefaultMoveRateAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readStartUpCurrentLevelAttribute(long chipClusterPtr, - StartUpCurrentLevelAttributeCallback callback - ); - - private native void writeStartUpCurrentLevelAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeStartUpCurrentLevelAttribute(long chipClusterPtr, - StartUpCurrentLevelAttributeCallback 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); - } + private native void readCurrentLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public static class LocalizationConfigurationCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 43L; + private native void subscribeCurrentLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public LocalizationConfigurationCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void readRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - @Override - public native long initWithDevice(long devicePtr, int endpointId); + private native void subscribeRemainingTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public interface SupportedLocalesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void readMinLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readActiveLocaleAttribute( - CharStringAttributeCallback callback - ) { - readActiveLocaleAttribute(chipClusterPtr, callback); - } - public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value) { - writeActiveLocaleAttribute(chipClusterPtr, callback, value, null); + private native void subscribeMinLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxFrequencyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOptionsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOptionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnOffTransitionTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOnOffTransitionTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnOffTransitionTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnLevelAttribute( + long chipClusterPtr, OnLevelAttributeCallback callback); + + private native void writeOnLevelAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnLevelAttribute( + long chipClusterPtr, OnLevelAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnTransitionTimeAttribute( + long chipClusterPtr, OnTransitionTimeAttributeCallback callback); + + private native void writeOnTransitionTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnTransitionTimeAttribute( + long chipClusterPtr, + OnTransitionTimeAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOffTransitionTimeAttribute( + long chipClusterPtr, OffTransitionTimeAttributeCallback callback); + + private native void writeOffTransitionTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOffTransitionTimeAttribute( + long chipClusterPtr, + OffTransitionTimeAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readDefaultMoveRateAttribute( + long chipClusterPtr, DefaultMoveRateAttributeCallback callback); + + private native void writeDefaultMoveRateAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeDefaultMoveRateAttribute( + long chipClusterPtr, + DefaultMoveRateAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readStartUpCurrentLevelAttribute( + long chipClusterPtr, StartUpCurrentLevelAttributeCallback callback); + + private native void writeStartUpCurrentLevelAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeStartUpCurrentLevelAttribute( + long chipClusterPtr, + StartUpCurrentLevelAttributeCallback 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 LocalizationConfigurationCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 43L; + + public LocalizationConfigurationCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface SupportedLocalesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void readActiveLocaleAttribute(CharStringAttributeCallback callback) { + readActiveLocaleAttribute(chipClusterPtr, callback); + } + + public void writeActiveLocaleAttribute(DefaultClusterCallback callback, String value) { + writeActiveLocaleAttribute(chipClusterPtr, callback, value, null); + } + + public void writeActiveLocaleAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeActiveLocaleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeActiveLocaleAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveLocaleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedLocalesAttribute( - SupportedLocalesAttributeCallback callback - ) { + public void readSupportedLocalesAttribute(SupportedLocalesAttributeCallback callback) { readSupportedLocalesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedLocalesAttribute( - SupportedLocalesAttributeCallback callback - , - int minInterval, int maxInterval) { + SupportedLocalesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedLocalesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readActiveLocaleAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeActiveLocaleAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeActiveLocaleAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedLocalesAttribute(long chipClusterPtr, - SupportedLocalesAttributeCallback callback - ); - private native void subscribeSupportedLocalesAttribute(long chipClusterPtr, - SupportedLocalesAttributeCallback 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); + private native void readActiveLocaleAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeActiveLocaleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeActiveLocaleAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSupportedLocalesAttribute( + long chipClusterPtr, SupportedLocalesAttributeCallback callback); + + private native void subscribeSupportedLocalesAttribute( + long chipClusterPtr, + SupportedLocalesAttributeCallback 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 LowPowerCluster extends BaseChipCluster { @@ -7366,63 +8166,60 @@ public LowPowerCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void sleep(DefaultClusterCallback callback - ) { + public void sleep(DefaultClusterCallback callback) { sleep(chipClusterPtr, callback, null); } - public void sleep(DefaultClusterCallback callback + public void sleep(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { sleep(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void sleep(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void sleep( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - private native void readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class MediaInputCluster extends BaseChipCluster { @@ -7435,148 +8232,146 @@ public MediaInputCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void hideInputStatusRequest(DefaultClusterCallback callback - ) { + public void hideInputStatusRequest(DefaultClusterCallback callback) { hideInputStatusRequest(chipClusterPtr, callback, null); } - public void hideInputStatusRequest(DefaultClusterCallback callback + public void hideInputStatusRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { hideInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void renameInputRequest(DefaultClusterCallback callback - , Integer index, String name) { + public void renameInputRequest(DefaultClusterCallback callback, Integer index, String name) { renameInputRequest(chipClusterPtr, callback, index, name, null); } - public void renameInputRequest(DefaultClusterCallback callback - , Integer index, String name - , int timedInvokeTimeoutMs) { + public void renameInputRequest( + DefaultClusterCallback callback, Integer index, String name, int timedInvokeTimeoutMs) { renameInputRequest(chipClusterPtr, callback, index, name, timedInvokeTimeoutMs); } - public void selectInputRequest(DefaultClusterCallback callback - , Integer index) { + public void selectInputRequest(DefaultClusterCallback callback, Integer index) { selectInputRequest(chipClusterPtr, callback, index, null); } - public void selectInputRequest(DefaultClusterCallback callback - , Integer index - , int timedInvokeTimeoutMs) { + public void selectInputRequest( + DefaultClusterCallback callback, Integer index, int timedInvokeTimeoutMs) { selectInputRequest(chipClusterPtr, callback, index, timedInvokeTimeoutMs); } - public void showInputStatusRequest(DefaultClusterCallback callback - ) { + public void showInputStatusRequest(DefaultClusterCallback callback) { showInputStatusRequest(chipClusterPtr, callback, null); } - public void showInputStatusRequest(DefaultClusterCallback callback + public void showInputStatusRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { showInputStatusRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void hideInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void renameInputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index, String name - , @Nullable Integer timedInvokeTimeoutMs); - private native void selectInputRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Integer index - , @Nullable Integer timedInvokeTimeoutMs); - private native void showInputStatusRequest(long chipClusterPtr, DefaultClusterCallback Callback + private native void hideInputStatusRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); + private native void renameInputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + String name, + @Nullable Integer timedInvokeTimeoutMs); - public interface MediaInputListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void selectInputRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer index, + @Nullable Integer timedInvokeTimeoutMs); + + private native void showInputStatusRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface MediaInputListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readMediaInputListAttribute( - MediaInputListAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMediaInputListAttribute(MediaInputListAttributeCallback callback) { readMediaInputListAttribute(chipClusterPtr, callback); } + public void subscribeMediaInputListAttribute( - MediaInputListAttributeCallback callback - , - int minInterval, int maxInterval) { + MediaInputListAttributeCallback callback, int minInterval, int maxInterval) { subscribeMediaInputListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentMediaInputAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentMediaInputAttribute(IntegerAttributeCallback callback) { readCurrentMediaInputAttribute(chipClusterPtr, callback); } + public void subscribeCurrentMediaInputAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentMediaInputAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMediaInputListAttribute(long chipClusterPtr, - MediaInputListAttributeCallback callback - ); - private native void subscribeMediaInputListAttribute(long chipClusterPtr, - MediaInputListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentMediaInputAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentMediaInputAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMediaInputListAttribute( + long chipClusterPtr, MediaInputListAttributeCallback callback); + + private native void subscribeMediaInputListAttribute( + long chipClusterPtr, + MediaInputListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentMediaInputAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentMediaInputAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class MediaPlaybackCluster extends BaseChipCluster { @@ -7589,323 +8384,304 @@ public MediaPlaybackCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void fastForwardRequest(PlaybackResponseCallback callback - ) { + public void fastForwardRequest(PlaybackResponseCallback callback) { fastForwardRequest(chipClusterPtr, callback, null); } - public void fastForwardRequest(PlaybackResponseCallback callback + public void fastForwardRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { fastForwardRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void nextRequest(PlaybackResponseCallback callback - ) { + public void nextRequest(PlaybackResponseCallback callback) { nextRequest(chipClusterPtr, callback, null); } - public void nextRequest(PlaybackResponseCallback callback + public void nextRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { nextRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void pauseRequest(PlaybackResponseCallback callback - ) { + public void pauseRequest(PlaybackResponseCallback callback) { pauseRequest(chipClusterPtr, callback, null); } - public void pauseRequest(PlaybackResponseCallback callback + public void pauseRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { pauseRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void playRequest(PlaybackResponseCallback callback - ) { + public void playRequest(PlaybackResponseCallback callback) { playRequest(chipClusterPtr, callback, null); } - public void playRequest(PlaybackResponseCallback callback + public void playRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { playRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void previousRequest(PlaybackResponseCallback callback - ) { + public void previousRequest(PlaybackResponseCallback callback) { previousRequest(chipClusterPtr, callback, null); } - public void previousRequest(PlaybackResponseCallback callback + public void previousRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { previousRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void rewindRequest(PlaybackResponseCallback callback - ) { + public void rewindRequest(PlaybackResponseCallback callback) { rewindRequest(chipClusterPtr, callback, null); } - public void rewindRequest(PlaybackResponseCallback callback + public void rewindRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { rewindRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void seekRequest(PlaybackResponseCallback callback - , Long position) { + public void seekRequest(PlaybackResponseCallback callback, Long position) { seekRequest(chipClusterPtr, callback, position, null); } - public void seekRequest(PlaybackResponseCallback callback - , Long position - , int timedInvokeTimeoutMs) { + public void seekRequest( + PlaybackResponseCallback callback, Long position, int timedInvokeTimeoutMs) { seekRequest(chipClusterPtr, callback, position, timedInvokeTimeoutMs); } - public void skipBackwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds) { + public void skipBackwardRequest( + PlaybackResponseCallback callback, Long deltaPositionMilliseconds) { skipBackwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, null); } - public void skipBackwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds - , int timedInvokeTimeoutMs) { - skipBackwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); + public void skipBackwardRequest( + PlaybackResponseCallback callback, + Long deltaPositionMilliseconds, + int timedInvokeTimeoutMs) { + skipBackwardRequest( + chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); } - public void skipForwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds) { + public void skipForwardRequest( + PlaybackResponseCallback callback, Long deltaPositionMilliseconds) { skipForwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, null); } - public void skipForwardRequest(PlaybackResponseCallback callback - , Long deltaPositionMilliseconds - , int timedInvokeTimeoutMs) { + public void skipForwardRequest( + PlaybackResponseCallback callback, + Long deltaPositionMilliseconds, + int timedInvokeTimeoutMs) { skipForwardRequest(chipClusterPtr, callback, deltaPositionMilliseconds, timedInvokeTimeoutMs); } - public void startOverRequest(PlaybackResponseCallback callback - ) { + public void startOverRequest(PlaybackResponseCallback callback) { startOverRequest(chipClusterPtr, callback, null); } - public void startOverRequest(PlaybackResponseCallback callback + public void startOverRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { startOverRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void stopRequest(PlaybackResponseCallback callback - ) { + public void stopRequest(PlaybackResponseCallback callback) { stopRequest(chipClusterPtr, callback, null); } - public void stopRequest(PlaybackResponseCallback callback + public void stopRequest(PlaybackResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { stopRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void fastForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void nextRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void pauseRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void playRequest(long chipClusterPtr, PlaybackResponseCallback Callback + private native void fastForwardRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void nextRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void pauseRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void playRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void previousRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void rewindRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void seekRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + Long position, + @Nullable Integer timedInvokeTimeoutMs); + + private native void skipBackwardRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + Long deltaPositionMilliseconds, + @Nullable Integer timedInvokeTimeoutMs); + + private native void skipForwardRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + Long deltaPositionMilliseconds, + @Nullable Integer timedInvokeTimeoutMs); + + private native void startOverRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopRequest( + long chipClusterPtr, + PlaybackResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void previousRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void rewindRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void seekRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , Long position - , @Nullable Integer timedInvokeTimeoutMs); - private native void skipBackwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , Long deltaPositionMilliseconds - , @Nullable Integer timedInvokeTimeoutMs); - private native void skipForwardRequest(long chipClusterPtr, PlaybackResponseCallback Callback - , Long deltaPositionMilliseconds - , @Nullable Integer timedInvokeTimeoutMs); - private native void startOverRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopRequest(long chipClusterPtr, PlaybackResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); public interface PlaybackResponseCallback { void onSuccess(Integer status); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readPlaybackStateAttribute( - IntegerAttributeCallback callback - ) { + public void readPlaybackStateAttribute(IntegerAttributeCallback callback) { readPlaybackStateAttribute(chipClusterPtr, callback); } + public void subscribePlaybackStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePlaybackStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartTimeAttribute( - LongAttributeCallback callback - ) { + public void readStartTimeAttribute(LongAttributeCallback callback) { readStartTimeAttribute(chipClusterPtr, callback); } + public void subscribeStartTimeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDurationAttribute( - LongAttributeCallback callback - ) { + public void readDurationAttribute(LongAttributeCallback callback) { readDurationAttribute(chipClusterPtr, callback); } + public void subscribeDurationAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeDurationAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPlaybackSpeedAttribute( - FloatAttributeCallback callback - ) { + public void readPlaybackSpeedAttribute(FloatAttributeCallback callback) { readPlaybackSpeedAttribute(chipClusterPtr, callback); } + public void subscribePlaybackSpeedAttribute( - FloatAttributeCallback callback -, - int minInterval, int maxInterval) { + FloatAttributeCallback callback, int minInterval, int maxInterval) { subscribePlaybackSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSeekRangeEndAttribute( - LongAttributeCallback callback - ) { + public void readSeekRangeEndAttribute(LongAttributeCallback callback) { readSeekRangeEndAttribute(chipClusterPtr, callback); } + public void subscribeSeekRangeEndAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeSeekRangeEndAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSeekRangeStartAttribute( - LongAttributeCallback callback - ) { + public void readSeekRangeStartAttribute(LongAttributeCallback callback) { readSeekRangeStartAttribute(chipClusterPtr, callback); } + public void subscribeSeekRangeStartAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeSeekRangeStartAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readPlaybackStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePlaybackStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeStartTimeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDurationAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeDurationAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPlaybackSpeedAttribute(long chipClusterPtr, - FloatAttributeCallback callback - ); - private native void subscribePlaybackSpeedAttribute(long chipClusterPtr, - FloatAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSeekRangeEndAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeSeekRangeEndAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSeekRangeStartAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeSeekRangeStartAttribute(long chipClusterPtr, - LongAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readPlaybackStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePlaybackStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartTimeAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeStartTimeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDurationAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeDurationAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPlaybackSpeedAttribute( + long chipClusterPtr, FloatAttributeCallback callback); + + private native void subscribePlaybackSpeedAttribute( + long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSeekRangeEndAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeSeekRangeEndAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSeekRangeStartAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeSeekRangeStartAttribute( + long chipClusterPtr, LongAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ModeSelectCluster extends BaseChipCluster { @@ -7918,172 +8694,164 @@ public ModeSelectCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void changeToMode(DefaultClusterCallback callback - , Integer newMode) { + public void changeToMode(DefaultClusterCallback callback, Integer newMode) { changeToMode(chipClusterPtr, callback, newMode, null); } - public void changeToMode(DefaultClusterCallback callback - , Integer newMode - , int timedInvokeTimeoutMs) { + public void changeToMode( + DefaultClusterCallback callback, Integer newMode, int timedInvokeTimeoutMs) { changeToMode(chipClusterPtr, callback, newMode, timedInvokeTimeoutMs); } - private native void changeToMode(long chipClusterPtr, DefaultClusterCallback Callback - , Integer newMode - , @Nullable Integer timedInvokeTimeoutMs); - public interface SupportedModesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void changeToMode( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer newMode, + @Nullable Integer timedInvokeTimeoutMs); + + public interface SupportedModesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readCurrentModeAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentModeAttribute(IntegerAttributeCallback callback) { readCurrentModeAttribute(chipClusterPtr, callback); } + public void subscribeCurrentModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedModesAttribute( - SupportedModesAttributeCallback callback - ) { + public void readSupportedModesAttribute(SupportedModesAttributeCallback callback) { readSupportedModesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedModesAttribute( - SupportedModesAttributeCallback callback - , - int minInterval, int maxInterval) { + SupportedModesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedModesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnModeAttribute( - IntegerAttributeCallback callback - ) { + public void readOnModeAttribute(IntegerAttributeCallback callback) { readOnModeAttribute(chipClusterPtr, callback); } + public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value) { writeOnModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpModeAttribute( - IntegerAttributeCallback callback - ) { + public void readStartUpModeAttribute(IntegerAttributeCallback callback) { readStartUpModeAttribute(chipClusterPtr, callback); } + public void subscribeStartUpModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartUpModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDescriptionAttribute( - CharStringAttributeCallback callback - ) { + public void readDescriptionAttribute(CharStringAttributeCallback callback) { readDescriptionAttribute(chipClusterPtr, callback); } + public void subscribeDescriptionAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readCurrentModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedModesAttribute(long chipClusterPtr, - SupportedModesAttributeCallback callback - ); - private native void subscribeSupportedModesAttribute(long chipClusterPtr, - SupportedModesAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOnModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOnModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartUpModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStartUpModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readCurrentModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSupportedModesAttribute( + long chipClusterPtr, SupportedModesAttributeCallback callback); + + private native void subscribeSupportedModesAttribute( + long chipClusterPtr, + SupportedModesAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOnModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOnModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartUpModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStartUpModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDescriptionAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeDescriptionAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class NetworkCommissioningCluster extends BaseChipCluster { @@ -8096,89 +8864,135 @@ public NetworkCommissioningCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback - , byte[] operationalDataset, Long breadcrumb) { + public void addOrUpdateThreadNetwork( + NetworkConfigResponseCallback callback, byte[] operationalDataset, Long breadcrumb) { addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, null); } - public void addOrUpdateThreadNetwork(NetworkConfigResponseCallback callback - , byte[] operationalDataset, Long breadcrumb - , int timedInvokeTimeoutMs) { - addOrUpdateThreadNetwork(chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs); + public void addOrUpdateThreadNetwork( + NetworkConfigResponseCallback callback, + byte[] operationalDataset, + Long breadcrumb, + int timedInvokeTimeoutMs) { + addOrUpdateThreadNetwork( + chipClusterPtr, callback, operationalDataset, breadcrumb, timedInvokeTimeoutMs); } - public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback - , byte[] ssid, byte[] credentials, Long breadcrumb) { + public void addOrUpdateWiFiNetwork( + NetworkConfigResponseCallback callback, byte[] ssid, byte[] credentials, Long breadcrumb) { addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, null); } - public void addOrUpdateWiFiNetwork(NetworkConfigResponseCallback callback - , byte[] ssid, byte[] credentials, Long breadcrumb - , int timedInvokeTimeoutMs) { - addOrUpdateWiFiNetwork(chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs); + public void addOrUpdateWiFiNetwork( + NetworkConfigResponseCallback callback, + byte[] ssid, + byte[] credentials, + Long breadcrumb, + int timedInvokeTimeoutMs) { + addOrUpdateWiFiNetwork( + chipClusterPtr, callback, ssid, credentials, breadcrumb, timedInvokeTimeoutMs); } - public void connectNetwork(ConnectNetworkResponseCallback callback - , byte[] networkID, Long breadcrumb) { + public void connectNetwork( + ConnectNetworkResponseCallback callback, byte[] networkID, Long breadcrumb) { connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); } - public void connectNetwork(ConnectNetworkResponseCallback callback - , byte[] networkID, Long breadcrumb - , int timedInvokeTimeoutMs) { + public void connectNetwork( + ConnectNetworkResponseCallback callback, + byte[] networkID, + Long breadcrumb, + int timedInvokeTimeoutMs) { connectNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); } - public void removeNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Long breadcrumb) { + public void removeNetwork( + NetworkConfigResponseCallback callback, byte[] networkID, Long breadcrumb) { removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, null); } - public void removeNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Long breadcrumb - , int timedInvokeTimeoutMs) { + public void removeNetwork( + NetworkConfigResponseCallback callback, + byte[] networkID, + Long breadcrumb, + int timedInvokeTimeoutMs) { removeNetwork(chipClusterPtr, callback, networkID, breadcrumb, timedInvokeTimeoutMs); } - public void reorderNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Integer networkIndex, Long breadcrumb) { + public void reorderNetwork( + NetworkConfigResponseCallback callback, + byte[] networkID, + Integer networkIndex, + Long breadcrumb) { reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, null); } - public void reorderNetwork(NetworkConfigResponseCallback callback - , byte[] networkID, Integer networkIndex, Long breadcrumb - , int timedInvokeTimeoutMs) { - reorderNetwork(chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs); + public void reorderNetwork( + NetworkConfigResponseCallback callback, + byte[] networkID, + Integer networkIndex, + Long breadcrumb, + int timedInvokeTimeoutMs) { + reorderNetwork( + chipClusterPtr, callback, networkID, networkIndex, breadcrumb, timedInvokeTimeoutMs); } - public void scanNetworks(ScanNetworksResponseCallback callback - , byte[] ssid, Long breadcrumb) { + public void scanNetworks(ScanNetworksResponseCallback callback, byte[] ssid, Long breadcrumb) { scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, null); } - public void scanNetworks(ScanNetworksResponseCallback callback - , byte[] ssid, Long breadcrumb - , int timedInvokeTimeoutMs) { + public void scanNetworks( + ScanNetworksResponseCallback callback, + byte[] ssid, + Long breadcrumb, + int timedInvokeTimeoutMs) { scanNetworks(chipClusterPtr, callback, ssid, breadcrumb, timedInvokeTimeoutMs); } - private native void addOrUpdateThreadNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] operationalDataset, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void addOrUpdateWiFiNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] ssid, byte[] credentials, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void connectNetwork(long chipClusterPtr, ConnectNetworkResponseCallback Callback - , byte[] networkID, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] networkID, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void reorderNetwork(long chipClusterPtr, NetworkConfigResponseCallback Callback - , byte[] networkID, Integer networkIndex, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); - private native void scanNetworks(long chipClusterPtr, ScanNetworksResponseCallback Callback - , byte[] ssid, Long breadcrumb - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addOrUpdateThreadNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] operationalDataset, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void addOrUpdateWiFiNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] ssid, + byte[] credentials, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void connectNetwork( + long chipClusterPtr, + ConnectNetworkResponseCallback Callback, + byte[] networkID, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] networkID, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void reorderNetwork( + long chipClusterPtr, + NetworkConfigResponseCallback Callback, + byte[] networkID, + Integer networkIndex, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + + private native void scanNetworks( + long chipClusterPtr, + ScanNetworksResponseCallback Callback, + byte[] ssid, + Long breadcrumb, + @Nullable Integer timedInvokeTimeoutMs); + public interface ConnectNetworkResponseCallback { void onSuccess(Integer networkingStatus, String debugText, Long errorValue); @@ -8192,216 +9006,192 @@ public interface NetworkConfigResponseCallback { } public interface ScanNetworksResponseCallback { - void onSuccess(Integer networkingStatus, String debugText, Optional> wiFiScanResults, Optional> threadScanResults); + void onSuccess( + Integer networkingStatus, + String debugText, + Optional> + wiFiScanResults, + Optional> + threadScanResults); void onError(Exception error); } + public interface NetworksAttributeCallback { + void onSuccess(List valueList); - public interface NetworksAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readMaxNetworksAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxNetworksAttribute(IntegerAttributeCallback callback) { readMaxNetworksAttribute(chipClusterPtr, callback); } + public void subscribeMaxNetworksAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNetworksAttribute( - NetworksAttributeCallback callback - ) { + public void readNetworksAttribute(NetworksAttributeCallback callback) { readNetworksAttribute(chipClusterPtr, callback); } + public void subscribeNetworksAttribute( - NetworksAttributeCallback callback - , - int minInterval, int maxInterval) { + NetworksAttributeCallback callback, int minInterval, int maxInterval) { subscribeNetworksAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readScanMaxTimeSecondsAttribute( - IntegerAttributeCallback callback - ) { + public void readScanMaxTimeSecondsAttribute(IntegerAttributeCallback callback) { readScanMaxTimeSecondsAttribute(chipClusterPtr, callback); } + public void subscribeScanMaxTimeSecondsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeScanMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readConnectMaxTimeSecondsAttribute( - IntegerAttributeCallback callback - ) { + public void readConnectMaxTimeSecondsAttribute(IntegerAttributeCallback callback) { readConnectMaxTimeSecondsAttribute(chipClusterPtr, callback); } + public void subscribeConnectMaxTimeSecondsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeConnectMaxTimeSecondsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInterfaceEnabledAttribute( - BooleanAttributeCallback callback - ) { + public void readInterfaceEnabledAttribute(BooleanAttributeCallback callback) { readInterfaceEnabledAttribute(chipClusterPtr, callback); } + public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value) { writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, null); } - public void writeInterfaceEnabledAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeInterfaceEnabledAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeInterfaceEnabledAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInterfaceEnabledAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeInterfaceEnabledAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastNetworkingStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readLastNetworkingStatusAttribute(IntegerAttributeCallback callback) { readLastNetworkingStatusAttribute(chipClusterPtr, callback); } + public void subscribeLastNetworkingStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLastNetworkingStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastNetworkIDAttribute( - OctetStringAttributeCallback callback - ) { + public void readLastNetworkIDAttribute(OctetStringAttributeCallback callback) { readLastNetworkIDAttribute(chipClusterPtr, callback); } + public void subscribeLastNetworkIDAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLastNetworkIDAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLastConnectErrorValueAttribute( - LongAttributeCallback callback - ) { + public void readLastConnectErrorValueAttribute(LongAttributeCallback callback) { readLastConnectErrorValueAttribute(chipClusterPtr, callback); } + public void subscribeLastConnectErrorValueAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeLastConnectErrorValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMaxNetworksAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxNetworksAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNetworksAttribute(long chipClusterPtr, - NetworksAttributeCallback callback - ); - private native void subscribeNetworksAttribute(long chipClusterPtr, - NetworksAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readScanMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeScanMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readConnectMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeConnectMaxTimeSecondsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInterfaceEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeInterfaceEnabledAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInterfaceEnabledAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLastNetworkingStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLastNetworkingStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLastNetworkIDAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeLastNetworkIDAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLastConnectErrorValueAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeLastConnectErrorValueAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readMaxNetworksAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxNetworksAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNetworksAttribute( + long chipClusterPtr, NetworksAttributeCallback callback); + + private native void subscribeNetworksAttribute( + long chipClusterPtr, NetworksAttributeCallback callback, int minInterval, int maxInterval); + + private native void readScanMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeScanMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readConnectMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeConnectMaxTimeSecondsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInterfaceEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeInterfaceEnabledAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInterfaceEnabledAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLastNetworkingStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLastNetworkingStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLastNetworkIDAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeLastNetworkIDAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLastConnectErrorValueAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeLastConnectErrorValueAttribute( + long chipClusterPtr, LongAttributeCallback 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 OtaSoftwareUpdateProviderCluster extends BaseChipCluster { @@ -8414,47 +9204,109 @@ public OtaSoftwareUpdateProviderCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void applyUpdateRequest(ApplyUpdateResponseCallback callback - , byte[] updateToken, Long newVersion) { + public void applyUpdateRequest( + ApplyUpdateResponseCallback callback, byte[] updateToken, Long newVersion) { applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, null); } - public void applyUpdateRequest(ApplyUpdateResponseCallback callback - , byte[] updateToken, Long newVersion - , int timedInvokeTimeoutMs) { + public void applyUpdateRequest( + ApplyUpdateResponseCallback callback, + byte[] updateToken, + Long newVersion, + int timedInvokeTimeoutMs) { applyUpdateRequest(chipClusterPtr, callback, updateToken, newVersion, timedInvokeTimeoutMs); } - public void notifyUpdateApplied(DefaultClusterCallback callback - , byte[] updateToken, Long softwareVersion) { + public void notifyUpdateApplied( + DefaultClusterCallback callback, byte[] updateToken, Long softwareVersion) { notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, null); } - public void notifyUpdateApplied(DefaultClusterCallback callback - , byte[] updateToken, Long softwareVersion - , int timedInvokeTimeoutMs) { - notifyUpdateApplied(chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs); - } - - public void queryImage(QueryImageResponseCallback callback - , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider) { - queryImage(chipClusterPtr, callback, vendorId, productId, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, null); - } + public void notifyUpdateApplied( + DefaultClusterCallback callback, + byte[] updateToken, + Long softwareVersion, + int timedInvokeTimeoutMs) { + notifyUpdateApplied( + chipClusterPtr, callback, updateToken, softwareVersion, timedInvokeTimeoutMs); + } + + public void queryImage( + QueryImageResponseCallback callback, + Integer vendorId, + Integer productId, + Long softwareVersion, + ArrayList protocolsSupported, + Optional hardwareVersion, + Optional location, + Optional requestorCanConsent, + Optional metadataForProvider) { + queryImage( + chipClusterPtr, + callback, + vendorId, + productId, + softwareVersion, + protocolsSupported, + hardwareVersion, + location, + requestorCanConsent, + metadataForProvider, + null); + } + + public void queryImage( + QueryImageResponseCallback callback, + Integer vendorId, + Integer productId, + Long softwareVersion, + ArrayList protocolsSupported, + Optional hardwareVersion, + Optional location, + Optional requestorCanConsent, + Optional metadataForProvider, + int timedInvokeTimeoutMs) { + queryImage( + chipClusterPtr, + callback, + vendorId, + productId, + softwareVersion, + protocolsSupported, + hardwareVersion, + location, + requestorCanConsent, + metadataForProvider, + timedInvokeTimeoutMs); + } + + private native void applyUpdateRequest( + long chipClusterPtr, + ApplyUpdateResponseCallback Callback, + byte[] updateToken, + Long newVersion, + @Nullable Integer timedInvokeTimeoutMs); + + private native void notifyUpdateApplied( + long chipClusterPtr, + DefaultClusterCallback Callback, + byte[] updateToken, + Long softwareVersion, + @Nullable Integer timedInvokeTimeoutMs); + + private native void queryImage( + long chipClusterPtr, + QueryImageResponseCallback Callback, + Integer vendorId, + Integer productId, + Long softwareVersion, + ArrayList protocolsSupported, + Optional hardwareVersion, + Optional location, + Optional requestorCanConsent, + Optional metadataForProvider, + @Nullable Integer timedInvokeTimeoutMs); - public void queryImage(QueryImageResponseCallback callback - , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider - , int timedInvokeTimeoutMs) { - queryImage(chipClusterPtr, callback, vendorId, productId, softwareVersion, protocolsSupported, hardwareVersion, location, requestorCanConsent, metadataForProvider, timedInvokeTimeoutMs); - } - private native void applyUpdateRequest(long chipClusterPtr, ApplyUpdateResponseCallback Callback - , byte[] updateToken, Long newVersion - , @Nullable Integer timedInvokeTimeoutMs); - private native void notifyUpdateApplied(long chipClusterPtr, DefaultClusterCallback Callback - , byte[] updateToken, Long softwareVersion - , @Nullable Integer timedInvokeTimeoutMs); - private native void queryImage(long chipClusterPtr, QueryImageResponseCallback Callback - , Integer vendorId, Integer productId, Long softwareVersion, ArrayList protocolsSupported, Optional hardwareVersion, Optional location, Optional requestorCanConsent, Optional metadataForProvider - , @Nullable Integer timedInvokeTimeoutMs); public interface ApplyUpdateResponseCallback { void onSuccess(Integer action, Long delayedActionTime); @@ -8462,55 +9314,59 @@ public interface ApplyUpdateResponseCallback { } public interface QueryImageResponseCallback { - void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor); + void onSuccess( + Integer status, + Optional delayedActionTime, + Optional imageURI, + Optional softwareVersion, + Optional softwareVersionString, + Optional updateToken, + Optional userConsentNeeded, + Optional metadataForRequestor); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback callback - ); - private native void subscribeAttributeListAttribute(long chipClusterPtr, - AttributeListAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 OtaSoftwareUpdateRequestorCluster extends BaseChipCluster { @@ -8523,158 +9379,194 @@ public OtaSoftwareUpdateRequestorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void announceOtaProvider(DefaultClusterCallback callback - , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint) { - announceOtaProvider(chipClusterPtr, callback, providerNodeId, vendorId, announcementReason, metadataForNode, endpoint, null); + public void announceOtaProvider( + DefaultClusterCallback callback, + Long providerNodeId, + Integer vendorId, + Integer announcementReason, + Optional metadataForNode, + Integer endpoint) { + announceOtaProvider( + chipClusterPtr, + callback, + providerNodeId, + vendorId, + announcementReason, + metadataForNode, + endpoint, + null); } - public void announceOtaProvider(DefaultClusterCallback callback - , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint - , int timedInvokeTimeoutMs) { - announceOtaProvider(chipClusterPtr, callback, providerNodeId, vendorId, announcementReason, metadataForNode, endpoint, timedInvokeTimeoutMs); + public void announceOtaProvider( + DefaultClusterCallback callback, + Long providerNodeId, + Integer vendorId, + Integer announcementReason, + Optional metadataForNode, + Integer endpoint, + int timedInvokeTimeoutMs) { + announceOtaProvider( + chipClusterPtr, + callback, + providerNodeId, + vendorId, + announcementReason, + metadataForNode, + endpoint, + timedInvokeTimeoutMs); } - private native void announceOtaProvider(long chipClusterPtr, DefaultClusterCallback Callback - , Long providerNodeId, Integer vendorId, Integer announcementReason, Optional metadataForNode, Integer endpoint - , @Nullable Integer timedInvokeTimeoutMs); - public interface DefaultOtaProvidersAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface UpdateStateProgressAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void announceOtaProvider( + long chipClusterPtr, + DefaultClusterCallback Callback, + Long providerNodeId, + Integer vendorId, + Integer announcementReason, + Optional metadataForNode, + Integer endpoint, + @Nullable Integer timedInvokeTimeoutMs); + + public interface DefaultOtaProvidersAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface UpdateStateProgressAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readDefaultOtaProvidersAttribute( - DefaultOtaProvidersAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readDefaultOtaProvidersAttribute(DefaultOtaProvidersAttributeCallback callback) { readDefaultOtaProvidersAttribute(chipClusterPtr, callback); } - public void writeDefaultOtaProvidersAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeDefaultOtaProvidersAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeDefaultOtaProvidersAttribute(chipClusterPtr, callback, value, null); } - public void writeDefaultOtaProvidersAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeDefaultOtaProvidersAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeDefaultOtaProvidersAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeDefaultOtaProvidersAttribute( - DefaultOtaProvidersAttributeCallback callback - , - int minInterval, int maxInterval) { + DefaultOtaProvidersAttributeCallback callback, int minInterval, int maxInterval) { subscribeDefaultOtaProvidersAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdatePossibleAttribute( - BooleanAttributeCallback callback - ) { + public void readUpdatePossibleAttribute(BooleanAttributeCallback callback) { readUpdatePossibleAttribute(chipClusterPtr, callback); } + public void subscribeUpdatePossibleAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpdatePossibleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdateStateAttribute( - IntegerAttributeCallback callback - ) { + public void readUpdateStateAttribute(IntegerAttributeCallback callback) { readUpdateStateAttribute(chipClusterPtr, callback); } + public void subscribeUpdateStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpdateStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUpdateStateProgressAttribute( - UpdateStateProgressAttributeCallback callback - ) { + public void readUpdateStateProgressAttribute(UpdateStateProgressAttributeCallback callback) { readUpdateStateProgressAttribute(chipClusterPtr, callback); } + public void subscribeUpdateStateProgressAttribute( - UpdateStateProgressAttributeCallback callback - , - int minInterval, int maxInterval) { + UpdateStateProgressAttributeCallback callback, int minInterval, int maxInterval) { subscribeUpdateStateProgressAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readDefaultOtaProvidersAttribute(long chipClusterPtr, - DefaultOtaProvidersAttributeCallback callback - ); - - private native void writeDefaultOtaProvidersAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeDefaultOtaProvidersAttribute(long chipClusterPtr, - DefaultOtaProvidersAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readUpdatePossibleAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeUpdatePossibleAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUpdateStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeUpdateStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUpdateStateProgressAttribute(long chipClusterPtr, - UpdateStateProgressAttributeCallback callback - ); - private native void subscribeUpdateStateProgressAttribute(long chipClusterPtr, - UpdateStateProgressAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readDefaultOtaProvidersAttribute( + long chipClusterPtr, DefaultOtaProvidersAttributeCallback callback); + + private native void writeDefaultOtaProvidersAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeDefaultOtaProvidersAttribute( + long chipClusterPtr, + DefaultOtaProvidersAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readUpdatePossibleAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeUpdatePossibleAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUpdateStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeUpdateStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUpdateStateProgressAttribute( + long chipClusterPtr, UpdateStateProgressAttributeCallback callback); + + private native void subscribeUpdateStateProgressAttribute( + long chipClusterPtr, + UpdateStateProgressAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class OccupancySensingCluster extends BaseChipCluster { @@ -8687,106 +9579,92 @@ public OccupancySensingCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readOccupancyAttribute( - IntegerAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readOccupancyAttribute(IntegerAttributeCallback callback) { readOccupancyAttribute(chipClusterPtr, callback); } + public void subscribeOccupancyAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupancyAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupancySensorTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupancySensorTypeAttribute(IntegerAttributeCallback callback) { readOccupancySensorTypeAttribute(chipClusterPtr, callback); } + public void subscribeOccupancySensorTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupancySensorTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupancySensorTypeBitmapAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupancySensorTypeBitmapAttribute(IntegerAttributeCallback callback) { readOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback); } + public void subscribeOccupancySensorTypeBitmapAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeOccupancySensorTypeBitmapAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeOccupancySensorTypeBitmapAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOccupancyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOccupancyAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupancySensorTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOccupancySensorTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupancySensorTypeBitmapAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOccupancySensorTypeBitmapAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readOccupancyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOccupancyAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOccupancySensorTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupancySensorTypeBitmapAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOccupancySensorTypeBitmapAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class OnOffCluster extends BaseChipCluster { @@ -8799,274 +9677,281 @@ public OnOffCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void off(DefaultClusterCallback callback - ) { + public void off(DefaultClusterCallback callback) { off(chipClusterPtr, callback, null); } - public void off(DefaultClusterCallback callback + public void off(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { off(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void offWithEffect(DefaultClusterCallback callback - , Integer effectId, Integer effectVariant) { + public void offWithEffect( + DefaultClusterCallback callback, Integer effectId, Integer effectVariant) { offWithEffect(chipClusterPtr, callback, effectId, effectVariant, null); } - public void offWithEffect(DefaultClusterCallback callback - , Integer effectId, Integer effectVariant - , int timedInvokeTimeoutMs) { + public void offWithEffect( + DefaultClusterCallback callback, + Integer effectId, + Integer effectVariant, + int timedInvokeTimeoutMs) { offWithEffect(chipClusterPtr, callback, effectId, effectVariant, timedInvokeTimeoutMs); } - public void on(DefaultClusterCallback callback - ) { + public void on(DefaultClusterCallback callback) { on(chipClusterPtr, callback, null); } - public void on(DefaultClusterCallback callback + public void on(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { on(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void onWithRecallGlobalScene(DefaultClusterCallback callback - ) { + public void onWithRecallGlobalScene(DefaultClusterCallback callback) { onWithRecallGlobalScene(chipClusterPtr, callback, null); } - public void onWithRecallGlobalScene(DefaultClusterCallback callback + public void onWithRecallGlobalScene(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { onWithRecallGlobalScene(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void onWithTimedOff(DefaultClusterCallback callback - , Integer onOffControl, Integer onTime, Integer offWaitTime) { + public void onWithTimedOff( + DefaultClusterCallback callback, + Integer onOffControl, + Integer onTime, + Integer offWaitTime) { onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, null); } - public void onWithTimedOff(DefaultClusterCallback callback - , Integer onOffControl, Integer onTime, Integer offWaitTime - , int timedInvokeTimeoutMs) { - onWithTimedOff(chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs); + public void onWithTimedOff( + DefaultClusterCallback callback, + Integer onOffControl, + Integer onTime, + Integer offWaitTime, + int timedInvokeTimeoutMs) { + onWithTimedOff( + chipClusterPtr, callback, onOffControl, onTime, offWaitTime, timedInvokeTimeoutMs); } - public void toggle(DefaultClusterCallback callback - ) { + public void toggle(DefaultClusterCallback callback) { toggle(chipClusterPtr, callback, null); } - public void toggle(DefaultClusterCallback callback + public void toggle(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { toggle(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void off(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); - private native void offWithEffect(long chipClusterPtr, DefaultClusterCallback Callback - , Integer effectId, Integer effectVariant - , @Nullable Integer timedInvokeTimeoutMs); - private native void on(long chipClusterPtr, DefaultClusterCallback Callback + private native void off( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void onWithRecallGlobalScene(long chipClusterPtr, DefaultClusterCallback Callback + private native void offWithEffect( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer effectId, + Integer effectVariant, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); - private native void onWithTimedOff(long chipClusterPtr, DefaultClusterCallback Callback - , Integer onOffControl, Integer onTime, Integer offWaitTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void toggle(long chipClusterPtr, DefaultClusterCallback Callback + private native void on( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - , @Nullable Integer timedInvokeTimeoutMs); + private native void onWithRecallGlobalScene( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void onWithTimedOff( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer onOffControl, + Integer onTime, + Integer offWaitTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void toggle( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public void readOnOffAttribute( - BooleanAttributeCallback callback - ) { + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readOnOffAttribute(BooleanAttributeCallback callback) { readOnOffAttribute(chipClusterPtr, callback); } + public void subscribeOnOffAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGlobalSceneControlAttribute( - BooleanAttributeCallback callback - ) { + public void readGlobalSceneControlAttribute(BooleanAttributeCallback callback) { readGlobalSceneControlAttribute(chipClusterPtr, callback); } + public void subscribeGlobalSceneControlAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeGlobalSceneControlAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOnTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readOnTimeAttribute(IntegerAttributeCallback callback) { readOnTimeAttribute(chipClusterPtr, callback); } + public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOnTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOnTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOnTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOnTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOnTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOnTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOffWaitTimeAttribute( - IntegerAttributeCallback callback - ) { + public void readOffWaitTimeAttribute(IntegerAttributeCallback callback) { readOffWaitTimeAttribute(chipClusterPtr, callback); } + public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value) { writeOffWaitTimeAttribute(chipClusterPtr, callback, value, null); } - public void writeOffWaitTimeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOffWaitTimeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOffWaitTimeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOffWaitTimeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOffWaitTimeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartUpOnOffAttribute( - IntegerAttributeCallback callback - ) { + public void readStartUpOnOffAttribute(IntegerAttributeCallback callback) { readStartUpOnOffAttribute(chipClusterPtr, callback); } + public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value) { writeStartUpOnOffAttribute(chipClusterPtr, callback, value, null); } - public void writeStartUpOnOffAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeStartUpOnOffAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeStartUpOnOffAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeStartUpOnOffAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartUpOnOffAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readOnOffAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeOnOffAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readGlobalSceneControlAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeGlobalSceneControlAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOnTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOnTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOnTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOffWaitTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOffWaitTimeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOffWaitTimeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartUpOnOffAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeStartUpOnOffAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeStartUpOnOffAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readOnOffAttribute(long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeOnOffAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readGlobalSceneControlAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeGlobalSceneControlAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOnTimeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOnTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOnTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOffWaitTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOffWaitTimeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOffWaitTimeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartUpOnOffAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeStartUpOnOffAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeStartUpOnOffAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 OnOffSwitchConfigurationCluster extends BaseChipCluster { @@ -9079,96 +9964,91 @@ public OnOffSwitchConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readSwitchTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readSwitchTypeAttribute(IntegerAttributeCallback callback) { readSwitchTypeAttribute(chipClusterPtr, callback); } + public void subscribeSwitchTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSwitchTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSwitchActionsAttribute( - IntegerAttributeCallback callback - ) { + public void readSwitchActionsAttribute(IntegerAttributeCallback callback) { readSwitchActionsAttribute(chipClusterPtr, callback); } + public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value) { writeSwitchActionsAttribute(chipClusterPtr, callback, value, null); } - public void writeSwitchActionsAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSwitchActionsAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSwitchActionsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeSwitchActionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSwitchActionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSwitchTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSwitchTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSwitchActionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeSwitchActionsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSwitchActionsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readSwitchTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSwitchTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSwitchActionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeSwitchActionsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSwitchActionsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class OperationalCredentialsCluster extends BaseChipCluster { @@ -9181,131 +10061,183 @@ public OperationalCredentialsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId) { - addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminNode, adminVendorId, null); - } - - public void addNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId - , int timedInvokeTimeoutMs) { - addNOC(chipClusterPtr, callback, NOCValue, ICACValue, IPKValue, caseAdminNode, adminVendorId, timedInvokeTimeoutMs); - } - - public void addTrustedRootCertificate(DefaultClusterCallback callback - , byte[] rootCertificate) { + public void addNOC( + NOCResponseCallback callback, + byte[] NOCValue, + Optional ICACValue, + byte[] IPKValue, + Long caseAdminNode, + Integer adminVendorId) { + addNOC( + chipClusterPtr, + callback, + NOCValue, + ICACValue, + IPKValue, + caseAdminNode, + adminVendorId, + null); + } + + public void addNOC( + NOCResponseCallback callback, + byte[] NOCValue, + Optional ICACValue, + byte[] IPKValue, + Long caseAdminNode, + Integer adminVendorId, + int timedInvokeTimeoutMs) { + addNOC( + chipClusterPtr, + callback, + NOCValue, + ICACValue, + IPKValue, + caseAdminNode, + adminVendorId, + timedInvokeTimeoutMs); + } + + public void addTrustedRootCertificate(DefaultClusterCallback callback, byte[] rootCertificate) { addTrustedRootCertificate(chipClusterPtr, callback, rootCertificate, null); } - public void addTrustedRootCertificate(DefaultClusterCallback callback - , byte[] rootCertificate - , int timedInvokeTimeoutMs) { + public void addTrustedRootCertificate( + DefaultClusterCallback callback, byte[] rootCertificate, int timedInvokeTimeoutMs) { addTrustedRootCertificate(chipClusterPtr, callback, rootCertificate, timedInvokeTimeoutMs); } - public void attestationRequest(AttestationResponseCallback callback - , byte[] attestationNonce) { + public void attestationRequest(AttestationResponseCallback callback, byte[] attestationNonce) { attestationRequest(chipClusterPtr, callback, attestationNonce, null); } - public void attestationRequest(AttestationResponseCallback callback - , byte[] attestationNonce - , int timedInvokeTimeoutMs) { + public void attestationRequest( + AttestationResponseCallback callback, byte[] attestationNonce, int timedInvokeTimeoutMs) { attestationRequest(chipClusterPtr, callback, attestationNonce, timedInvokeTimeoutMs); } - public void certificateChainRequest(CertificateChainResponseCallback callback - , Integer certificateType) { + public void certificateChainRequest( + CertificateChainResponseCallback callback, Integer certificateType) { certificateChainRequest(chipClusterPtr, callback, certificateType, null); } - public void certificateChainRequest(CertificateChainResponseCallback callback - , Integer certificateType - , int timedInvokeTimeoutMs) { + public void certificateChainRequest( + CertificateChainResponseCallback callback, + Integer certificateType, + int timedInvokeTimeoutMs) { certificateChainRequest(chipClusterPtr, callback, certificateType, timedInvokeTimeoutMs); } - public void opCSRRequest(OpCSRResponseCallback callback - , byte[] CSRNonce) { + public void opCSRRequest(OpCSRResponseCallback callback, byte[] CSRNonce) { opCSRRequest(chipClusterPtr, callback, CSRNonce, null); } - public void opCSRRequest(OpCSRResponseCallback callback - , byte[] CSRNonce - , int timedInvokeTimeoutMs) { + public void opCSRRequest( + OpCSRResponseCallback callback, byte[] CSRNonce, int timedInvokeTimeoutMs) { opCSRRequest(chipClusterPtr, callback, CSRNonce, timedInvokeTimeoutMs); } - public void removeFabric(NOCResponseCallback callback - , Integer fabricIndex) { + public void removeFabric(NOCResponseCallback callback, Integer fabricIndex) { removeFabric(chipClusterPtr, callback, fabricIndex, null); } - public void removeFabric(NOCResponseCallback callback - , Integer fabricIndex - , int timedInvokeTimeoutMs) { + public void removeFabric( + NOCResponseCallback callback, Integer fabricIndex, int timedInvokeTimeoutMs) { removeFabric(chipClusterPtr, callback, fabricIndex, timedInvokeTimeoutMs); } - public void removeTrustedRootCertificate(DefaultClusterCallback callback - , byte[] trustedRootIdentifier) { + public void removeTrustedRootCertificate( + DefaultClusterCallback callback, byte[] trustedRootIdentifier) { removeTrustedRootCertificate(chipClusterPtr, callback, trustedRootIdentifier, null); } - public void removeTrustedRootCertificate(DefaultClusterCallback callback - , byte[] trustedRootIdentifier - , int timedInvokeTimeoutMs) { - removeTrustedRootCertificate(chipClusterPtr, callback, trustedRootIdentifier, timedInvokeTimeoutMs); + public void removeTrustedRootCertificate( + DefaultClusterCallback callback, byte[] trustedRootIdentifier, int timedInvokeTimeoutMs) { + removeTrustedRootCertificate( + chipClusterPtr, callback, trustedRootIdentifier, timedInvokeTimeoutMs); } - public void updateFabricLabel(NOCResponseCallback callback - , String label) { + public void updateFabricLabel(NOCResponseCallback callback, String label) { updateFabricLabel(chipClusterPtr, callback, label, null); } - public void updateFabricLabel(NOCResponseCallback callback - , String label - , int timedInvokeTimeoutMs) { + public void updateFabricLabel( + NOCResponseCallback callback, String label, int timedInvokeTimeoutMs) { updateFabricLabel(chipClusterPtr, callback, label, timedInvokeTimeoutMs); } - public void updateNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue) { + public void updateNOC( + NOCResponseCallback callback, byte[] NOCValue, Optional ICACValue) { updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, null); } - public void updateNOC(NOCResponseCallback callback - , byte[] NOCValue, Optional ICACValue - , int timedInvokeTimeoutMs) { + public void updateNOC( + NOCResponseCallback callback, + byte[] NOCValue, + Optional ICACValue, + int timedInvokeTimeoutMs) { updateNOC(chipClusterPtr, callback, NOCValue, ICACValue, timedInvokeTimeoutMs); } - private native void addNOC(long chipClusterPtr, NOCResponseCallback Callback - , byte[] NOCValue, Optional ICACValue, byte[] IPKValue, Long caseAdminNode, Integer adminVendorId - , @Nullable Integer timedInvokeTimeoutMs); - private native void addTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback Callback - , byte[] rootCertificate - , @Nullable Integer timedInvokeTimeoutMs); - private native void attestationRequest(long chipClusterPtr, AttestationResponseCallback Callback - , byte[] attestationNonce - , @Nullable Integer timedInvokeTimeoutMs); - private native void certificateChainRequest(long chipClusterPtr, CertificateChainResponseCallback Callback - , Integer certificateType - , @Nullable Integer timedInvokeTimeoutMs); - private native void opCSRRequest(long chipClusterPtr, OpCSRResponseCallback Callback - , byte[] CSRNonce - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeFabric(long chipClusterPtr, NOCResponseCallback Callback - , Integer fabricIndex - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeTrustedRootCertificate(long chipClusterPtr, DefaultClusterCallback Callback - , byte[] trustedRootIdentifier - , @Nullable Integer timedInvokeTimeoutMs); - private native void updateFabricLabel(long chipClusterPtr, NOCResponseCallback Callback - , String label - , @Nullable Integer timedInvokeTimeoutMs); - private native void updateNOC(long chipClusterPtr, NOCResponseCallback Callback - , byte[] NOCValue, Optional ICACValue - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addNOC( + long chipClusterPtr, + NOCResponseCallback Callback, + byte[] NOCValue, + Optional ICACValue, + byte[] IPKValue, + Long caseAdminNode, + Integer adminVendorId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void addTrustedRootCertificate( + long chipClusterPtr, + DefaultClusterCallback Callback, + byte[] rootCertificate, + @Nullable Integer timedInvokeTimeoutMs); + + private native void attestationRequest( + long chipClusterPtr, + AttestationResponseCallback Callback, + byte[] attestationNonce, + @Nullable Integer timedInvokeTimeoutMs); + + private native void certificateChainRequest( + long chipClusterPtr, + CertificateChainResponseCallback Callback, + Integer certificateType, + @Nullable Integer timedInvokeTimeoutMs); + + private native void opCSRRequest( + long chipClusterPtr, + OpCSRResponseCallback Callback, + byte[] CSRNonce, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeFabric( + long chipClusterPtr, + NOCResponseCallback Callback, + Integer fabricIndex, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeTrustedRootCertificate( + long chipClusterPtr, + DefaultClusterCallback Callback, + byte[] trustedRootIdentifier, + @Nullable Integer timedInvokeTimeoutMs); + + private native void updateFabricLabel( + long chipClusterPtr, + NOCResponseCallback Callback, + String label, + @Nullable Integer timedInvokeTimeoutMs); + + private native void updateNOC( + long chipClusterPtr, + NOCResponseCallback Callback, + byte[] NOCValue, + Optional ICACValue, + @Nullable Integer timedInvokeTimeoutMs); + public interface AttestationResponseCallback { void onSuccess(byte[] attestationElements, byte[] signature); @@ -9330,184 +10262,177 @@ public interface OpCSRResponseCallback { void onError(Exception error); } + public interface NOCsAttributeCallback { + void onSuccess(List valueList); - public interface NOCsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface FabricsListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface TrustedRootCertificatesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentFabricIndexAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface FabricsListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface TrustedRootCertificatesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readNOCsAttribute( - NOCsAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public interface CurrentFabricIndexAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readNOCsAttribute(NOCsAttributeCallback callback) { readNOCsAttribute(chipClusterPtr, callback); } + public void subscribeNOCsAttribute( - NOCsAttributeCallback callback - , - int minInterval, int maxInterval) { + NOCsAttributeCallback callback, int minInterval, int maxInterval) { subscribeNOCsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFabricsListAttribute( - FabricsListAttributeCallback callback - ) { + public void readFabricsListAttribute(FabricsListAttributeCallback callback) { readFabricsListAttribute(chipClusterPtr, callback); } + public void subscribeFabricsListAttribute( - FabricsListAttributeCallback callback - , - int minInterval, int maxInterval) { + FabricsListAttributeCallback callback, int minInterval, int maxInterval) { subscribeFabricsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSupportedFabricsAttribute( - IntegerAttributeCallback callback - ) { + public void readSupportedFabricsAttribute(IntegerAttributeCallback callback) { readSupportedFabricsAttribute(chipClusterPtr, callback); } + public void subscribeSupportedFabricsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCommissionedFabricsAttribute( - IntegerAttributeCallback callback - ) { + public void readCommissionedFabricsAttribute(IntegerAttributeCallback callback) { readCommissionedFabricsAttribute(chipClusterPtr, callback); } + public void subscribeCommissionedFabricsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCommissionedFabricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTrustedRootCertificatesAttribute( - TrustedRootCertificatesAttributeCallback callback - ) { + TrustedRootCertificatesAttributeCallback callback) { readTrustedRootCertificatesAttribute(chipClusterPtr, callback); } + public void subscribeTrustedRootCertificatesAttribute( - TrustedRootCertificatesAttributeCallback callback - , - int minInterval, int maxInterval) { + TrustedRootCertificatesAttributeCallback callback, int minInterval, int maxInterval) { subscribeTrustedRootCertificatesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentFabricIndexAttribute( - CurrentFabricIndexAttributeCallback callback - ) { + public void readCurrentFabricIndexAttribute(CurrentFabricIndexAttributeCallback callback) { readCurrentFabricIndexAttribute(chipClusterPtr, callback); } + public void subscribeCurrentFabricIndexAttribute( - CurrentFabricIndexAttributeCallback callback - , - int minInterval, int maxInterval) { + CurrentFabricIndexAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentFabricIndexAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNOCsAttribute(long chipClusterPtr, - NOCsAttributeCallback callback - ); - private native void subscribeNOCsAttribute(long chipClusterPtr, - NOCsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readFabricsListAttribute(long chipClusterPtr, - FabricsListAttributeCallback callback - ); - private native void subscribeFabricsListAttribute(long chipClusterPtr, - FabricsListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readSupportedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSupportedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCommissionedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCommissionedFabricsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTrustedRootCertificatesAttribute(long chipClusterPtr, - TrustedRootCertificatesAttributeCallback callback - ); - private native void subscribeTrustedRootCertificatesAttribute(long chipClusterPtr, - TrustedRootCertificatesAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentFabricIndexAttribute(long chipClusterPtr, - CurrentFabricIndexAttributeCallback callback - ); - private native void subscribeCurrentFabricIndexAttribute(long chipClusterPtr, - CurrentFabricIndexAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readNOCsAttribute(long chipClusterPtr, NOCsAttributeCallback callback); + + private native void subscribeNOCsAttribute( + long chipClusterPtr, NOCsAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFabricsListAttribute( + long chipClusterPtr, FabricsListAttributeCallback callback); + + private native void subscribeFabricsListAttribute( + long chipClusterPtr, + FabricsListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSupportedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSupportedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCommissionedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCommissionedFabricsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTrustedRootCertificatesAttribute( + long chipClusterPtr, TrustedRootCertificatesAttributeCallback callback); + + private native void subscribeTrustedRootCertificatesAttribute( + long chipClusterPtr, + TrustedRootCertificatesAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentFabricIndexAttribute( + long chipClusterPtr, CurrentFabricIndexAttributeCallback callback); + + private native void subscribeCurrentFabricIndexAttribute( + long chipClusterPtr, + CurrentFabricIndexAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class PowerSourceCluster extends BaseChipCluster { @@ -9520,244 +10445,208 @@ public PowerSourceCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface ActiveBatteryFaultsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface ActiveBatteryFaultsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readStatusAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readStatusAttribute(IntegerAttributeCallback callback) { readStatusAttribute(chipClusterPtr, callback); } + public void subscribeStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOrderAttribute( - IntegerAttributeCallback callback - ) { + public void readOrderAttribute(IntegerAttributeCallback callback) { readOrderAttribute(chipClusterPtr, callback); } + public void subscribeOrderAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOrderAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDescriptionAttribute( - CharStringAttributeCallback callback - ) { + public void readDescriptionAttribute(CharStringAttributeCallback callback) { readDescriptionAttribute(chipClusterPtr, callback); } + public void subscribeDescriptionAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeDescriptionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryVoltageAttribute( - LongAttributeCallback callback - ) { + public void readBatteryVoltageAttribute(LongAttributeCallback callback) { readBatteryVoltageAttribute(chipClusterPtr, callback); } + public void subscribeBatteryVoltageAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryVoltageAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryPercentRemainingAttribute( - IntegerAttributeCallback callback - ) { + public void readBatteryPercentRemainingAttribute(IntegerAttributeCallback callback) { readBatteryPercentRemainingAttribute(chipClusterPtr, callback); } + public void subscribeBatteryPercentRemainingAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryPercentRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryTimeRemainingAttribute( - LongAttributeCallback callback - ) { + public void readBatteryTimeRemainingAttribute(LongAttributeCallback callback) { readBatteryTimeRemainingAttribute(chipClusterPtr, callback); } + public void subscribeBatteryTimeRemainingAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryTimeRemainingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryChargeLevelAttribute( - IntegerAttributeCallback callback - ) { + public void readBatteryChargeLevelAttribute(IntegerAttributeCallback callback) { readBatteryChargeLevelAttribute(chipClusterPtr, callback); } + public void subscribeBatteryChargeLevelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryChargeLevelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveBatteryFaultsAttribute( - ActiveBatteryFaultsAttributeCallback callback - ) { + public void readActiveBatteryFaultsAttribute(ActiveBatteryFaultsAttributeCallback callback) { readActiveBatteryFaultsAttribute(chipClusterPtr, callback); } + public void subscribeActiveBatteryFaultsAttribute( - ActiveBatteryFaultsAttributeCallback callback - , - int minInterval, int maxInterval) { + ActiveBatteryFaultsAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveBatteryFaultsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBatteryChargeStateAttribute( - IntegerAttributeCallback callback - ) { + public void readBatteryChargeStateAttribute(IntegerAttributeCallback callback) { readBatteryChargeStateAttribute(chipClusterPtr, callback); } + public void subscribeBatteryChargeStateAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBatteryChargeStateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOrderAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOrderAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeDescriptionAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryVoltageAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBatteryVoltageAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryPercentRemainingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBatteryPercentRemainingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryTimeRemainingAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBatteryTimeRemainingAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBatteryChargeLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBatteryChargeLevelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveBatteryFaultsAttribute(long chipClusterPtr, - ActiveBatteryFaultsAttributeCallback callback - ); - private native void subscribeActiveBatteryFaultsAttribute(long chipClusterPtr, - ActiveBatteryFaultsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readBatteryChargeStateAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBatteryChargeStateAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readStatusAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOrderAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOrderAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDescriptionAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeDescriptionAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readBatteryVoltageAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBatteryVoltageAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBatteryPercentRemainingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBatteryPercentRemainingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBatteryTimeRemainingAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBatteryTimeRemainingAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBatteryChargeLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBatteryChargeLevelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveBatteryFaultsAttribute( + long chipClusterPtr, ActiveBatteryFaultsAttributeCallback callback); + + private native void subscribeActiveBatteryFaultsAttribute( + long chipClusterPtr, + ActiveBatteryFaultsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readBatteryChargeStateAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBatteryChargeStateAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 PowerSourceConfigurationCluster extends BaseChipCluster { @@ -9770,73 +10659,69 @@ public PowerSourceConfigurationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SourcesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface SourcesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readSourcesAttribute( - SourcesAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readSourcesAttribute(SourcesAttributeCallback callback) { readSourcesAttribute(chipClusterPtr, callback); } + public void subscribeSourcesAttribute( - SourcesAttributeCallback callback - , - int minInterval, int maxInterval) { + SourcesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSourcesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSourcesAttribute(long chipClusterPtr, - SourcesAttributeCallback callback - ); - private native void subscribeSourcesAttribute(long chipClusterPtr, - SourcesAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readSourcesAttribute( + long chipClusterPtr, SourcesAttributeCallback callback); + + private native void subscribeSourcesAttribute( + long chipClusterPtr, SourcesAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class PressureMeasurementCluster extends BaseChipCluster { @@ -9849,106 +10734,91 @@ public PressureMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class PumpConfigurationAndControlCluster extends BaseChipCluster { @@ -9961,701 +10831,614 @@ public PumpConfigurationAndControlCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LifetimeRunningHoursAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface LifetimeEnergyConsumedAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface LifetimeRunningHoursAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface LifetimeEnergyConsumedAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); - public void readMaxPressureAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMaxPressureAttribute(IntegerAttributeCallback callback) { readMaxPressureAttribute(chipClusterPtr, callback); } + public void subscribeMaxPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxSpeedAttribute(IntegerAttributeCallback callback) { readMaxSpeedAttribute(chipClusterPtr, callback); } + public void subscribeMaxSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxFlowAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxFlowAttribute(IntegerAttributeCallback callback) { readMaxFlowAttribute(chipClusterPtr, callback); } + public void subscribeMaxFlowAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstPressureAttribute(IntegerAttributeCallback callback) { readMinConstPressureAttribute(chipClusterPtr, callback); } + public void subscribeMinConstPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstPressureAttribute(IntegerAttributeCallback callback) { readMaxConstPressureAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinCompPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMinCompPressureAttribute(IntegerAttributeCallback callback) { readMinCompPressureAttribute(chipClusterPtr, callback); } + public void subscribeMinCompPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxCompPressureAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxCompPressureAttribute(IntegerAttributeCallback callback) { readMaxCompPressureAttribute(chipClusterPtr, callback); } + public void subscribeMaxCompPressureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxCompPressureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstSpeedAttribute(IntegerAttributeCallback callback) { readMinConstSpeedAttribute(chipClusterPtr, callback); } + public void subscribeMinConstSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstSpeedAttribute(IntegerAttributeCallback callback) { readMaxConstSpeedAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstFlowAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstFlowAttribute(IntegerAttributeCallback callback) { readMinConstFlowAttribute(chipClusterPtr, callback); } + public void subscribeMinConstFlowAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstFlowAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstFlowAttribute(IntegerAttributeCallback callback) { readMaxConstFlowAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstFlowAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstFlowAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinConstTempAttribute( - IntegerAttributeCallback callback - ) { + public void readMinConstTempAttribute(IntegerAttributeCallback callback) { readMinConstTempAttribute(chipClusterPtr, callback); } + public void subscribeMinConstTempAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxConstTempAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxConstTempAttribute(IntegerAttributeCallback callback) { readMaxConstTempAttribute(chipClusterPtr, callback); } + public void subscribeMaxConstTempAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxConstTempAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPumpStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readPumpStatusAttribute(IntegerAttributeCallback callback) { readPumpStatusAttribute(chipClusterPtr, callback); } + public void subscribePumpStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePumpStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEffectiveOperationModeAttribute( - IntegerAttributeCallback callback - ) { + public void readEffectiveOperationModeAttribute(IntegerAttributeCallback callback) { readEffectiveOperationModeAttribute(chipClusterPtr, callback); } + public void subscribeEffectiveOperationModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEffectiveOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEffectiveControlModeAttribute( - IntegerAttributeCallback callback - ) { + public void readEffectiveControlModeAttribute(IntegerAttributeCallback callback) { readEffectiveControlModeAttribute(chipClusterPtr, callback); } + public void subscribeEffectiveControlModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEffectiveControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCapacityAttribute( - IntegerAttributeCallback callback - ) { + public void readCapacityAttribute(IntegerAttributeCallback callback) { readCapacityAttribute(chipClusterPtr, callback); } + public void subscribeCapacityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCapacityAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSpeedAttribute( - IntegerAttributeCallback callback - ) { + public void readSpeedAttribute(IntegerAttributeCallback callback) { readSpeedAttribute(chipClusterPtr, callback); } + public void subscribeSpeedAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSpeedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLifetimeRunningHoursAttribute( - LifetimeRunningHoursAttributeCallback callback - ) { + public void readLifetimeRunningHoursAttribute(LifetimeRunningHoursAttributeCallback callback) { readLifetimeRunningHoursAttribute(chipClusterPtr, callback); } + public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value) { writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, null); } - public void writeLifetimeRunningHoursAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeLifetimeRunningHoursAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeLifetimeRunningHoursAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLifetimeRunningHoursAttribute( - LifetimeRunningHoursAttributeCallback callback - , - int minInterval, int maxInterval) { + LifetimeRunningHoursAttributeCallback callback, int minInterval, int maxInterval) { subscribeLifetimeRunningHoursAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPowerAttribute( - LongAttributeCallback callback - ) { + public void readPowerAttribute(LongAttributeCallback callback) { readPowerAttribute(chipClusterPtr, callback); } + public void subscribePowerAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePowerAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readLifetimeEnergyConsumedAttribute( - LifetimeEnergyConsumedAttributeCallback callback - ) { + LifetimeEnergyConsumedAttributeCallback callback) { readLifetimeEnergyConsumedAttribute(chipClusterPtr, callback); } + public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value) { writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, null); } - public void writeLifetimeEnergyConsumedAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeLifetimeEnergyConsumedAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLifetimeEnergyConsumedAttribute( - LifetimeEnergyConsumedAttributeCallback callback - , - int minInterval, int maxInterval) { + LifetimeEnergyConsumedAttributeCallback callback, int minInterval, int maxInterval) { subscribeLifetimeEnergyConsumedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperationModeAttribute( - IntegerAttributeCallback callback - ) { + public void readOperationModeAttribute(IntegerAttributeCallback callback) { readOperationModeAttribute(chipClusterPtr, callback); } + public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value) { writeOperationModeAttribute(chipClusterPtr, callback, value, null); } - public void writeOperationModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOperationModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOperationModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOperationModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOperationModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readControlModeAttribute( - IntegerAttributeCallback callback - ) { + public void readControlModeAttribute(IntegerAttributeCallback callback) { readControlModeAttribute(chipClusterPtr, callback); } + public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value) { writeControlModeAttribute(chipClusterPtr, callback, value, null); } - public void writeControlModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeControlModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeControlModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeControlModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeControlModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAlarmMaskAttribute( - IntegerAttributeCallback callback - ) { + public void readAlarmMaskAttribute(IntegerAttributeCallback callback) { readAlarmMaskAttribute(chipClusterPtr, callback); } + public void subscribeAlarmMaskAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAlarmMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMaxPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxCompPressureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstFlowAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxConstTempAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPumpStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePumpStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEffectiveOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEffectiveOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEffectiveControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEffectiveControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCapacityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCapacityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSpeedAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLifetimeRunningHoursAttribute(long chipClusterPtr, - LifetimeRunningHoursAttributeCallback callback - ); - - private native void writeLifetimeRunningHoursAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLifetimeRunningHoursAttribute(long chipClusterPtr, - LifetimeRunningHoursAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readPowerAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePowerAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLifetimeEnergyConsumedAttribute(long chipClusterPtr, - LifetimeEnergyConsumedAttributeCallback callback - ); - - private native void writeLifetimeEnergyConsumedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLifetimeEnergyConsumedAttribute(long chipClusterPtr, - LifetimeEnergyConsumedAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOperationModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOperationModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeControlModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeControlModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAlarmMaskAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAlarmMaskAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); - } + private native void readMaxPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public static class RelativeHumidityMeasurementCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1029L; + private native void subscribeMaxPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); - } + private native void readMaxSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - @Override - public native long initWithDevice(long devicePtr, int endpointId); + private native void subscribeMaxSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + private native void readMaxFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { - readMeasuredValueAttribute(chipClusterPtr, callback); - } - public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeMaxFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { - readMinMeasuredValueAttribute(chipClusterPtr, callback); - } - public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readMinConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { - readMaxMeasuredValueAttribute(chipClusterPtr, callback); - } - public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeMinConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { - readToleranceAttribute(chipClusterPtr, callback); - } - public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readMaxConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { - readAttributeListAttribute(chipClusterPtr, callback); - } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeMaxConstPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { - readClusterRevisionAttribute(chipClusterPtr, callback); + private native void readMinCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxCompPressureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxConstSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxConstFlowAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxConstTempAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPumpStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePumpStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEffectiveOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEffectiveOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEffectiveControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEffectiveControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCapacityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCapacityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSpeedAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSpeedAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLifetimeRunningHoursAttribute( + long chipClusterPtr, LifetimeRunningHoursAttributeCallback callback); + + private native void writeLifetimeRunningHoursAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLifetimeRunningHoursAttribute( + long chipClusterPtr, + LifetimeRunningHoursAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPowerAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePowerAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLifetimeEnergyConsumedAttribute( + long chipClusterPtr, LifetimeEnergyConsumedAttributeCallback callback); + + private native void writeLifetimeEnergyConsumedAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLifetimeEnergyConsumedAttribute( + long chipClusterPtr, + LifetimeEnergyConsumedAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOperationModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOperationModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeControlModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeControlModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAlarmMaskAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAlarmMaskAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 RelativeHumidityMeasurementCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1029L; + + public RelativeHumidityMeasurementCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { + readMeasuredValueAttribute(chipClusterPtr, callback); + } + + public void subscribeMeasuredValueAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { + readMinMeasuredValueAttribute(chipClusterPtr, callback); + } + + public void subscribeMinMeasuredValueAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { + readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + + public void subscribeMaxMeasuredValueAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readToleranceAttribute(IntegerAttributeCallback callback) { + readToleranceAttribute(chipClusterPtr, callback); + } + + public void subscribeToleranceAttribute( + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeToleranceAttribute(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 readClusterRevisionAttribute(IntegerAttributeCallback callback) { + readClusterRevisionAttribute(chipClusterPtr, callback); + } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ScenesCluster extends BaseChipCluster { @@ -10668,103 +11451,163 @@ public ScenesCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void addScene(AddSceneResponseCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { - addScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, sceneName, extensionFieldSets, null); - } - - public void addScene(AddSceneResponseCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets - , int timedInvokeTimeoutMs) { - addScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, sceneName, extensionFieldSets, timedInvokeTimeoutMs); - } - - public void getSceneMembership(GetSceneMembershipResponseCallback callback - , Integer groupId) { + public void addScene( + AddSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets) { + addScene( + chipClusterPtr, + callback, + groupId, + sceneId, + transitionTime, + sceneName, + extensionFieldSets, + null); + } + + public void addScene( + AddSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets, + int timedInvokeTimeoutMs) { + addScene( + chipClusterPtr, + callback, + groupId, + sceneId, + transitionTime, + sceneName, + extensionFieldSets, + timedInvokeTimeoutMs); + } + + public void getSceneMembership(GetSceneMembershipResponseCallback callback, Integer groupId) { getSceneMembership(chipClusterPtr, callback, groupId, null); } - public void getSceneMembership(GetSceneMembershipResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void getSceneMembership( + GetSceneMembershipResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { getSceneMembership(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void recallScene(DefaultClusterCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime) { + public void recallScene( + DefaultClusterCallback callback, Integer groupId, Integer sceneId, Integer transitionTime) { recallScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, null); } - public void recallScene(DefaultClusterCallback callback - , Integer groupId, Integer sceneId, Integer transitionTime - , int timedInvokeTimeoutMs) { + public void recallScene( + DefaultClusterCallback callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + int timedInvokeTimeoutMs) { recallScene(chipClusterPtr, callback, groupId, sceneId, transitionTime, timedInvokeTimeoutMs); } - public void removeAllScenes(RemoveAllScenesResponseCallback callback - , Integer groupId) { + public void removeAllScenes(RemoveAllScenesResponseCallback callback, Integer groupId) { removeAllScenes(chipClusterPtr, callback, groupId, null); } - public void removeAllScenes(RemoveAllScenesResponseCallback callback - , Integer groupId - , int timedInvokeTimeoutMs) { + public void removeAllScenes( + RemoveAllScenesResponseCallback callback, Integer groupId, int timedInvokeTimeoutMs) { removeAllScenes(chipClusterPtr, callback, groupId, timedInvokeTimeoutMs); } - public void removeScene(RemoveSceneResponseCallback callback - , Integer groupId, Integer sceneId) { + public void removeScene( + RemoveSceneResponseCallback callback, Integer groupId, Integer sceneId) { removeScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void removeScene(RemoveSceneResponseCallback callback - , Integer groupId, Integer sceneId - , int timedInvokeTimeoutMs) { + public void removeScene( + RemoveSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + int timedInvokeTimeoutMs) { removeScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - public void storeScene(StoreSceneResponseCallback callback - , Integer groupId, Integer sceneId) { + public void storeScene(StoreSceneResponseCallback callback, Integer groupId, Integer sceneId) { storeScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void storeScene(StoreSceneResponseCallback callback - , Integer groupId, Integer sceneId - , int timedInvokeTimeoutMs) { + public void storeScene( + StoreSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + int timedInvokeTimeoutMs) { storeScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - public void viewScene(ViewSceneResponseCallback callback - , Integer groupId, Integer sceneId) { + public void viewScene(ViewSceneResponseCallback callback, Integer groupId, Integer sceneId) { viewScene(chipClusterPtr, callback, groupId, sceneId, null); } - public void viewScene(ViewSceneResponseCallback callback - , Integer groupId, Integer sceneId - , int timedInvokeTimeoutMs) { + public void viewScene( + ViewSceneResponseCallback callback, + Integer groupId, + Integer sceneId, + int timedInvokeTimeoutMs) { viewScene(chipClusterPtr, callback, groupId, sceneId, timedInvokeTimeoutMs); } - private native void addScene(long chipClusterPtr, AddSceneResponseCallback Callback - , Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets - , @Nullable Integer timedInvokeTimeoutMs); - private native void getSceneMembership(long chipClusterPtr, GetSceneMembershipResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); - private native void recallScene(long chipClusterPtr, DefaultClusterCallback Callback - , Integer groupId, Integer sceneId, Integer transitionTime - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeAllScenes(long chipClusterPtr, RemoveAllScenesResponseCallback Callback - , Integer groupId - , @Nullable Integer timedInvokeTimeoutMs); - private native void removeScene(long chipClusterPtr, RemoveSceneResponseCallback Callback - , Integer groupId, Integer sceneId - , @Nullable Integer timedInvokeTimeoutMs); - private native void storeScene(long chipClusterPtr, StoreSceneResponseCallback Callback - , Integer groupId, Integer sceneId - , @Nullable Integer timedInvokeTimeoutMs); - private native void viewScene(long chipClusterPtr, ViewSceneResponseCallback Callback - , Integer groupId, Integer sceneId - , @Nullable Integer timedInvokeTimeoutMs); + + private native void addScene( + long chipClusterPtr, + AddSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getSceneMembership( + long chipClusterPtr, + GetSceneMembershipResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void recallScene( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer groupId, + Integer sceneId, + Integer transitionTime, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeAllScenes( + long chipClusterPtr, + RemoveAllScenesResponseCallback Callback, + Integer groupId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void removeScene( + long chipClusterPtr, + RemoveSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void storeScene( + long chipClusterPtr, + StoreSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + @Nullable Integer timedInvokeTimeoutMs); + + private native void viewScene( + long chipClusterPtr, + ViewSceneResponseCallback Callback, + Integer groupId, + Integer sceneId, + @Nullable Integer timedInvokeTimeoutMs); + public interface AddSceneResponseCallback { void onSuccess(Integer status, Integer groupId, Integer sceneId); @@ -10772,7 +11615,12 @@ public interface AddSceneResponseCallback { } public interface GetSceneMembershipResponseCallback { - void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList); + void onSuccess( + Integer status, + Integer capacity, + Integer groupId, + Integer sceneCount, + ArrayList sceneList); void onError(Exception error); } @@ -10796,150 +11644,132 @@ public interface StoreSceneResponseCallback { } public interface ViewSceneResponseCallback { - void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets); + void onSuccess( + Integer status, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readSceneCountAttribute( - IntegerAttributeCallback callback - ) { + public void readSceneCountAttribute(IntegerAttributeCallback callback) { readSceneCountAttribute(chipClusterPtr, callback); } + public void subscribeSceneCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSceneCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentSceneAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentSceneAttribute(IntegerAttributeCallback callback) { readCurrentSceneAttribute(chipClusterPtr, callback); } + public void subscribeCurrentSceneAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentSceneAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentGroupAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentGroupAttribute(IntegerAttributeCallback callback) { readCurrentGroupAttribute(chipClusterPtr, callback); } + public void subscribeCurrentGroupAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentGroupAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSceneValidAttribute( - BooleanAttributeCallback callback - ) { + public void readSceneValidAttribute(BooleanAttributeCallback callback) { readSceneValidAttribute(chipClusterPtr, callback); } + public void subscribeSceneValidAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeSceneValidAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNameSupportAttribute( - IntegerAttributeCallback callback - ) { + public void readNameSupportAttribute(IntegerAttributeCallback callback) { readNameSupportAttribute(chipClusterPtr, callback); } + public void subscribeNameSupportAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNameSupportAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readSceneCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSceneCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentSceneAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentSceneAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentGroupAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentGroupAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSceneValidAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - private native void subscribeSceneValidAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNameSupportAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readSceneCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSceneCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentSceneAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentSceneAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentGroupAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentGroupAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSceneValidAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void subscribeSceneValidAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNameSupportAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class SoftwareDiagnosticsCluster extends BaseChipCluster { @@ -10952,163 +11782,147 @@ public SoftwareDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetWatermarks(DefaultClusterCallback callback - ) { + public void resetWatermarks(DefaultClusterCallback callback) { resetWatermarks(chipClusterPtr, callback, null); } - public void resetWatermarks(DefaultClusterCallback callback + public void resetWatermarks(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { resetWatermarks(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void resetWatermarks(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void resetWatermarks( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface ThreadMetricsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface ThreadMetricsAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readThreadMetricsAttribute( - ThreadMetricsAttributeCallback callback - ) { + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readThreadMetricsAttribute(ThreadMetricsAttributeCallback callback) { readThreadMetricsAttribute(chipClusterPtr, callback); } + public void subscribeThreadMetricsAttribute( - ThreadMetricsAttributeCallback callback - , - int minInterval, int maxInterval) { + ThreadMetricsAttributeCallback callback, int minInterval, int maxInterval) { subscribeThreadMetricsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapFreeAttribute( - LongAttributeCallback callback - ) { + public void readCurrentHeapFreeAttribute(LongAttributeCallback callback) { readCurrentHeapFreeAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHeapFreeAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentHeapFreeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapUsedAttribute( - LongAttributeCallback callback - ) { + public void readCurrentHeapUsedAttribute(LongAttributeCallback callback) { readCurrentHeapUsedAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHeapUsedAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentHeapUsedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentHeapHighWatermarkAttribute( - LongAttributeCallback callback - ) { + public void readCurrentHeapHighWatermarkAttribute(LongAttributeCallback callback) { readCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback); } + public void subscribeCurrentHeapHighWatermarkAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeCurrentHeapHighWatermarkAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCurrentHeapHighWatermarkAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readThreadMetricsAttribute(long chipClusterPtr, - ThreadMetricsAttributeCallback callback - ); - private native void subscribeThreadMetricsAttribute(long chipClusterPtr, - ThreadMetricsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentHeapFreeAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentHeapFreeAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentHeapUsedAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentHeapUsedAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentHeapHighWatermarkAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentHeapHighWatermarkAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readThreadMetricsAttribute( + long chipClusterPtr, ThreadMetricsAttributeCallback callback); + + private native void subscribeThreadMetricsAttribute( + long chipClusterPtr, + ThreadMetricsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentHeapFreeAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentHeapFreeAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentHeapUsedAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentHeapUsedAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentHeapHighWatermarkAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentHeapHighWatermarkAttribute( + long chipClusterPtr, LongAttributeCallback 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 SwitchCluster extends BaseChipCluster { @@ -11121,125 +11935,106 @@ public SwitchCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readNumberOfPositionsAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfPositionsAttribute(IntegerAttributeCallback callback) { readNumberOfPositionsAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfPositionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeNumberOfPositionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentPositionAttribute(IntegerAttributeCallback callback) { readCurrentPositionAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentPositionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMultiPressMaxAttribute( - IntegerAttributeCallback callback - ) { + public void readMultiPressMaxAttribute(IntegerAttributeCallback callback) { readMultiPressMaxAttribute(chipClusterPtr, callback); } + public void subscribeMultiPressMaxAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMultiPressMaxAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readNumberOfPositionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfPositionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentPositionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMultiPressMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMultiPressMaxAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readNumberOfPositionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfPositionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentPositionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMultiPressMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMultiPressMaxAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 TargetNavigatorCluster extends BaseChipCluster { @@ -11252,112 +12047,113 @@ public TargetNavigatorCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void navigateTargetRequest(NavigateTargetResponseCallback callback - , Integer target, String data) { + public void navigateTargetRequest( + NavigateTargetResponseCallback callback, Integer target, String data) { navigateTargetRequest(chipClusterPtr, callback, target, data, null); } - public void navigateTargetRequest(NavigateTargetResponseCallback callback - , Integer target, String data - , int timedInvokeTimeoutMs) { + public void navigateTargetRequest( + NavigateTargetResponseCallback callback, + Integer target, + String data, + int timedInvokeTimeoutMs) { navigateTargetRequest(chipClusterPtr, callback, target, data, timedInvokeTimeoutMs); } - private native void navigateTargetRequest(long chipClusterPtr, NavigateTargetResponseCallback Callback - , Integer target, String data - , @Nullable Integer timedInvokeTimeoutMs); + + private native void navigateTargetRequest( + long chipClusterPtr, + NavigateTargetResponseCallback Callback, + Integer target, + String data, + @Nullable Integer timedInvokeTimeoutMs); + public interface NavigateTargetResponseCallback { void onSuccess(Integer status, String data); void onError(Exception error); } + public interface TargetNavigatorListAttributeCallback { + void onSuccess(List valueList); - public interface TargetNavigatorListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readTargetNavigatorListAttribute( - TargetNavigatorListAttributeCallback callback - ) { + public void readTargetNavigatorListAttribute(TargetNavigatorListAttributeCallback callback) { readTargetNavigatorListAttribute(chipClusterPtr, callback); } + public void subscribeTargetNavigatorListAttribute( - TargetNavigatorListAttributeCallback callback - , - int minInterval, int maxInterval) { + TargetNavigatorListAttributeCallback callback, int minInterval, int maxInterval) { subscribeTargetNavigatorListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentNavigatorTargetAttribute( - IntegerAttributeCallback callback - ) { + public void readCurrentNavigatorTargetAttribute(IntegerAttributeCallback callback) { readCurrentNavigatorTargetAttribute(chipClusterPtr, callback); } + public void subscribeCurrentNavigatorTargetAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentNavigatorTargetAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTargetNavigatorListAttribute(long chipClusterPtr, - TargetNavigatorListAttributeCallback callback - ); - private native void subscribeTargetNavigatorListAttribute(long chipClusterPtr, - TargetNavigatorListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentNavigatorTargetAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeCurrentNavigatorTargetAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readTargetNavigatorListAttribute( + long chipClusterPtr, TargetNavigatorListAttributeCallback callback); + + private native void subscribeTargetNavigatorListAttribute( + long chipClusterPtr, + TargetNavigatorListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentNavigatorTargetAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeCurrentNavigatorTargetAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class TemperatureMeasurementCluster extends BaseChipCluster { @@ -11370,2838 +12166,3268 @@ public TemperatureMeasurementCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readMeasuredValueAttribute(IntegerAttributeCallback callback) { readMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMinMeasuredValueAttribute(IntegerAttributeCallback callback) { readMinMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMinMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxMeasuredValueAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxMeasuredValueAttribute(IntegerAttributeCallback callback) { readMaxMeasuredValueAttribute(chipClusterPtr, callback); } + public void subscribeMaxMeasuredValueAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxMeasuredValueAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readToleranceAttribute( - IntegerAttributeCallback callback - ) { + public void readToleranceAttribute(IntegerAttributeCallback callback) { readToleranceAttribute(chipClusterPtr, callback); } + public void subscribeToleranceAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeToleranceAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMinMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeMaxMeasuredValueAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeToleranceAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + private native void readMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMinMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeMaxMeasuredValueAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeToleranceAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class TestClusterCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 1295L; + + public TestClusterCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void simpleStructEchoRequest( + SimpleStructResponseCallback callback, ChipStructs.TestClusterClusterSimpleStruct arg1) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, null); + } + + public void simpleStructEchoRequest( + SimpleStructResponseCallback callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + int timedInvokeTimeoutMs) { + simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void test(DefaultClusterCallback callback) { + test(chipClusterPtr, callback, null); + } + + public void test(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + test(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testAddArguments( + TestAddArgumentsResponseCallback callback, Integer arg1, Integer arg2) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, null); + } + + public void testAddArguments( + TestAddArgumentsResponseCallback callback, + Integer arg1, + Integer arg2, + int timedInvokeTimeoutMs) { + testAddArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + } + + public void testEmitTestEventRequest( + TestEmitTestEventResponseCallback callback, Integer arg1, Integer arg2, Boolean arg3) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, null); + } + + public void testEmitTestEventRequest( + TestEmitTestEventResponseCallback callback, + Integer arg1, + Integer arg2, + Boolean arg3, + int timedInvokeTimeoutMs) { + testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, timedInvokeTimeoutMs); + } + + public void testEnumsRequest(TestEnumsResponseCallback callback, Integer arg1, Integer arg2) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, null); + } + + public void testEnumsRequest( + TestEnumsResponseCallback callback, Integer arg1, Integer arg2, int timedInvokeTimeoutMs) { + testEnumsRequest(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + } + + public void testListInt8UArgumentRequest( + BooleanResponseCallback callback, ArrayList arg1) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListInt8UArgumentRequest( + BooleanResponseCallback callback, ArrayList arg1, int timedInvokeTimeoutMs) { + testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListInt8UReverseRequest( + TestListInt8UReverseResponseCallback callback, ArrayList arg1) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListInt8UReverseRequest( + TestListInt8UReverseResponseCallback callback, + ArrayList arg1, + int timedInvokeTimeoutMs) { + testListInt8UReverseRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListNestedStructListArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListNestedStructListArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1, + int timedInvokeTimeoutMs) { + testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testListStructArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testListStructArgumentRequest( + BooleanResponseCallback callback, + ArrayList arg1, + int timedInvokeTimeoutMs) { + testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testNestedStructArgumentRequest( + BooleanResponseCallback callback, ChipStructs.TestClusterClusterNestedStruct arg1) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNestedStructArgumentRequest( + BooleanResponseCallback callback, + ChipStructs.TestClusterClusterNestedStruct arg1, + int timedInvokeTimeoutMs) { + testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testNestedStructListArgumentRequest( + BooleanResponseCallback callback, ChipStructs.TestClusterClusterNestedStructList arg1) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNestedStructListArgumentRequest( + BooleanResponseCallback callback, + ChipStructs.TestClusterClusterNestedStructList arg1, + int timedInvokeTimeoutMs) { + testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testNotHandled(DefaultClusterCallback callback) { + testNotHandled(chipClusterPtr, callback, null); + } + + public void testNotHandled(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testNullableOptionalRequest( + TestNullableOptionalResponseCallback callback, @Nullable Optional arg1) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, null); + } + + public void testNullableOptionalRequest( + TestNullableOptionalResponseCallback callback, + @Nullable Optional arg1, + int timedInvokeTimeoutMs) { + testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testSimpleOptionalArgumentRequest( + DefaultClusterCallback callback, Optional arg1) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testSimpleOptionalArgumentRequest( + DefaultClusterCallback callback, Optional arg1, int timedInvokeTimeoutMs) { + testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testSpecific(TestSpecificResponseCallback callback) { + testSpecific(chipClusterPtr, callback, null); + } + + public void testSpecific(TestSpecificResponseCallback callback, int timedInvokeTimeoutMs) { + + testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void testStructArgumentRequest( + BooleanResponseCallback callback, ChipStructs.TestClusterClusterSimpleStruct arg1) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, null); + } + + public void testStructArgumentRequest( + BooleanResponseCallback callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + int timedInvokeTimeoutMs) { + testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + } + + public void testUnknownCommand(DefaultClusterCallback callback) { + testUnknownCommand(chipClusterPtr, callback, null); + } + + public void testUnknownCommand(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + public void timedInvokeRequest(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + private native void simpleStructEchoRequest( + long chipClusterPtr, + SimpleStructResponseCallback Callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void test( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testAddArguments( + long chipClusterPtr, + TestAddArgumentsResponseCallback Callback, + Integer arg1, + Integer arg2, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testEmitTestEventRequest( + long chipClusterPtr, + TestEmitTestEventResponseCallback Callback, + Integer arg1, + Integer arg2, + Boolean arg3, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testEnumsRequest( + long chipClusterPtr, + TestEnumsResponseCallback Callback, + Integer arg1, + Integer arg2, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListInt8UArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListInt8UReverseRequest( + long chipClusterPtr, + TestListInt8UReverseResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListNestedStructListArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testListStructArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ArrayList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNestedStructArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ChipStructs.TestClusterClusterNestedStruct arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNestedStructListArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ChipStructs.TestClusterClusterNestedStructList arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNotHandled( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testNullableOptionalRequest( + long chipClusterPtr, + TestNullableOptionalResponseCallback Callback, + @Nullable Optional arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testSimpleOptionalArgumentRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + Optional arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testSpecific( + long chipClusterPtr, + TestSpecificResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testStructArgumentRequest( + long chipClusterPtr, + BooleanResponseCallback Callback, + ChipStructs.TestClusterClusterSimpleStruct arg1, + @Nullable Integer timedInvokeTimeoutMs); + + private native void testUnknownCommand( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void timedInvokeRequest( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface BooleanResponseCallback { + void onSuccess(Boolean value); + + void onError(Exception error); + } + + public interface SimpleStructResponseCallback { + void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); + + void onError(Exception error); + } + + public interface TestAddArgumentsResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } + + public interface TestEmitTestEventResponseCallback { + void onSuccess(Long value); + + void onError(Exception error); + } + + public interface TestEnumsResponseCallback { + void onSuccess(Integer arg1, Integer arg2); + + void onError(Exception error); + } + + public interface TestListInt8UReverseResponseCallback { + void onSuccess(ArrayList arg1); + + void onError(Exception error); + } + + public interface TestNullableOptionalResponseCallback { + void onSuccess( + Boolean wasPresent, + Optional wasNull, + Optional value, + @Nullable Optional originalValue); + + void onError(Exception error); + } + + public interface TestSpecificResponseCallback { + void onSuccess(Integer returnValue); + + void onError(Exception error); + } + + public interface ListInt8uAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListOctetStringAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListStructOctetStringAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface VendorIdAttributeCallback { + void onSuccess(Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListNullablesAndOptionalsStructAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface ListLongOctetStringAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBooleanAttributeCallback { + void onSuccess(@Nullable Boolean value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBitmap8AttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBitmap16AttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface NullableBitmap32AttributeCallback { + void onSuccess(@Nullable Long value); - public static class TestClusterCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 1295L; + void onError(Exception ex); - public TestClusterCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); + default void onSubscriptionEstablished() {} } - @Override - public native long initWithDevice(long devicePtr, int endpointId); + public interface NullableBitmap64AttributeCallback { + void onSuccess(@Nullable Long value); - public void simpleStructEchoRequest(SimpleStructResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1) { - simpleStructEchoRequest(chipClusterPtr, callback, arg1, null); - } + void onError(Exception ex); - public void simpleStructEchoRequest(SimpleStructResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , int timedInvokeTimeoutMs) { - simpleStructEchoRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void test(DefaultClusterCallback callback - ) { - test(chipClusterPtr, callback, null); - } + public interface NullableInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); - public void test(DefaultClusterCallback callback + void onError(Exception ex); - , int timedInvokeTimeoutMs) { - test(chipClusterPtr, callback, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testAddArguments(TestAddArgumentsResponseCallback callback - , Integer arg1, Integer arg2) { - testAddArguments(chipClusterPtr, callback, arg1, arg2, null); - } + public interface NullableInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); - public void testAddArguments(TestAddArgumentsResponseCallback callback - , Integer arg1, Integer arg2 - , int timedInvokeTimeoutMs) { - testAddArguments(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); - } + void onError(Exception ex); - public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback - , Integer arg1, Integer arg2, Boolean arg3) { - testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, null); + default void onSubscriptionEstablished() {} } - public void testEmitTestEventRequest(TestEmitTestEventResponseCallback callback - , Integer arg1, Integer arg2, Boolean arg3 - , int timedInvokeTimeoutMs) { - testEmitTestEventRequest(chipClusterPtr, callback, arg1, arg2, arg3, timedInvokeTimeoutMs); - } + public interface NullableInt24uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testEnumsRequest(TestEnumsResponseCallback callback - , Integer arg1, Integer arg2) { - testEnumsRequest(chipClusterPtr, callback, arg1, arg2, null); - } + void onError(Exception ex); - public void testEnumsRequest(TestEnumsResponseCallback callback - , Integer arg1, Integer arg2 - , int timedInvokeTimeoutMs) { - testEnumsRequest(chipClusterPtr, callback, arg1, arg2, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testListInt8UArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1) { - testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, null); - } + public interface NullableInt32uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testListInt8UArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListInt8UArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + void onError(Exception ex); - public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback - , ArrayList arg1) { - testListInt8UReverseRequest(chipClusterPtr, callback, arg1, null); + default void onSubscriptionEstablished() {} } - public void testListInt8UReverseRequest(TestListInt8UReverseResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListInt8UReverseRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + public interface NullableInt40uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1) { - testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); - } + void onError(Exception ex); - public void testListNestedStructListArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testListStructArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1) { - testListStructArgumentRequest(chipClusterPtr, callback, arg1, null); - } + public interface NullableInt48uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testListStructArgumentRequest(BooleanResponseCallback callback - , ArrayList arg1 - , int timedInvokeTimeoutMs) { - testListStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + void onError(Exception ex); - public void testNestedStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStruct arg1) { - testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, null); + default void onSubscriptionEstablished() {} } - public void testNestedStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStruct arg1 - , int timedInvokeTimeoutMs) { - testNestedStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); - } + public interface NullableInt56uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testNestedStructListArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStructList arg1) { - testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, null); - } + void onError(Exception ex); - public void testNestedStructListArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterNestedStructList arg1 - , int timedInvokeTimeoutMs) { - testNestedStructListArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testNotHandled(DefaultClusterCallback callback - ) { - testNotHandled(chipClusterPtr, callback, null); - } + public interface NullableInt64uAttributeCallback { + void onSuccess(@Nullable Long value); - public void testNotHandled(DefaultClusterCallback callback + void onError(Exception ex); - , int timedInvokeTimeoutMs) { - testNotHandled(chipClusterPtr, callback, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback - , @Nullable Optional arg1) { - testNullableOptionalRequest(chipClusterPtr, callback, arg1, null); + public interface NullableInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testNullableOptionalRequest(TestNullableOptionalResponseCallback callback - , @Nullable Optional arg1 - , int timedInvokeTimeoutMs) { - testNullableOptionalRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + public interface NullableInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback - , Optional arg1) { - testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, null); + public interface NullableInt24sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSimpleOptionalArgumentRequest(DefaultClusterCallback callback - , Optional arg1 - , int timedInvokeTimeoutMs) { - testSimpleOptionalArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + public interface NullableInt32sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSpecific(TestSpecificResponseCallback callback - ) { - testSpecific(chipClusterPtr, callback, null); + public interface NullableInt40sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testSpecific(TestSpecificResponseCallback callback + public interface NullableInt48sAttributeCallback { + void onSuccess(@Nullable Long value); - , int timedInvokeTimeoutMs) { - testSpecific(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1) { - testStructArgumentRequest(chipClusterPtr, callback, arg1, null); + public interface NullableInt56sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testStructArgumentRequest(BooleanResponseCallback callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , int timedInvokeTimeoutMs) { - testStructArgumentRequest(chipClusterPtr, callback, arg1, timedInvokeTimeoutMs); + public interface NullableInt64sAttributeCallback { + void onSuccess(@Nullable Long value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testUnknownCommand(DefaultClusterCallback callback - ) { - testUnknownCommand(chipClusterPtr, callback, null); + public interface NullableEnum8AttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void testUnknownCommand(DefaultClusterCallback callback + public interface NullableEnum16AttributeCallback { + void onSuccess(@Nullable Integer value); - , int timedInvokeTimeoutMs) { - testUnknownCommand(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } + public interface NullableFloatSingleAttributeCallback { + void onSuccess(@Nullable Float value); - public void timedInvokeRequest(DefaultClusterCallback callback + void onError(Exception ex); - , int timedInvokeTimeoutMs) { - timedInvokeRequest(chipClusterPtr, callback, timedInvokeTimeoutMs); + default void onSubscriptionEstablished() {} } - private native void simpleStructEchoRequest(long chipClusterPtr, SimpleStructResponseCallback Callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void test(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void testAddArguments(long chipClusterPtr, TestAddArgumentsResponseCallback Callback - , Integer arg1, Integer arg2 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testEmitTestEventRequest(long chipClusterPtr, TestEmitTestEventResponseCallback Callback - , Integer arg1, Integer arg2, Boolean arg3 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testEnumsRequest(long chipClusterPtr, TestEnumsResponseCallback Callback - , Integer arg1, Integer arg2 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListInt8UArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListInt8UReverseRequest(long chipClusterPtr, TestListInt8UReverseResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testListStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ArrayList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNestedStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ChipStructs.TestClusterClusterNestedStruct arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNestedStructListArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ChipStructs.TestClusterClusterNestedStructList arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNotHandled(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void testNullableOptionalRequest(long chipClusterPtr, TestNullableOptionalResponseCallback Callback - , @Nullable Optional arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testSimpleOptionalArgumentRequest(long chipClusterPtr, DefaultClusterCallback Callback - , Optional arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testSpecific(long chipClusterPtr, TestSpecificResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void testStructArgumentRequest(long chipClusterPtr, BooleanResponseCallback Callback - , ChipStructs.TestClusterClusterSimpleStruct arg1 - , @Nullable Integer timedInvokeTimeoutMs); - private native void testUnknownCommand(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void timedInvokeRequest(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - public interface BooleanResponseCallback { - void onSuccess(Boolean value); - void onError(Exception error); + public interface NullableFloatDoubleAttributeCallback { + void onSuccess(@Nullable Double value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface SimpleStructResponseCallback { - void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1); + public interface NullableOctetStringAttributeCallback { + void onSuccess(@Nullable byte[] value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestAddArgumentsResponseCallback { - void onSuccess(Integer returnValue); + public interface NullableCharStringAttributeCallback { + void onSuccess(@Nullable String value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestEmitTestEventResponseCallback { - void onSuccess(Long value); + public interface NullableEnumAttrAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestEnumsResponseCallback { - void onSuccess(Integer arg1, Integer arg2); + public interface NullableRangeRestrictedInt8uAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestListInt8UReverseResponseCallback { - void onSuccess(ArrayList arg1); + public interface NullableRangeRestrictedInt8sAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestNullableOptionalResponseCallback { - void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue); + public interface NullableRangeRestrictedInt16uAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public interface TestSpecificResponseCallback { - void onSuccess(Integer returnValue); + public interface NullableRangeRestrictedInt16sAttributeCallback { + void onSuccess(@Nullable Integer value); - void onError(Exception error); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface ListInt8uAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListOctetStringAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListStructOctetStringAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface VendorIdAttributeCallback { - void onSuccess( Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListNullablesAndOptionalsStructAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ListLongOctetStringAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBooleanAttributeCallback { - void onSuccess(@Nullable Boolean value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap8AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap16AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap32AttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableBitmap64AttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt8uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt16uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt24uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt32uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt40uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt48uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt56uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt64uAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt8sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt16sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt24sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt32sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt40sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt48sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt56sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableInt64sAttributeCallback { - void onSuccess(@Nullable Long value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableEnum8AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableEnum16AttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableFloatSingleAttributeCallback { - void onSuccess(@Nullable Float value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableFloatDoubleAttributeCallback { - void onSuccess(@Nullable Double value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableOctetStringAttributeCallback { - void onSuccess(@Nullable byte[] value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableCharStringAttributeCallback { - void onSuccess(@Nullable String value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableEnumAttrAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt8uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt8sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt16uAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface NullableRangeRestrictedInt16sAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readBooleanAttribute(BooleanAttributeCallback callback) { readBooleanAttribute(chipClusterPtr, callback); } + public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap8Attribute( - IntegerAttributeCallback callback - ) { + public void readBitmap8Attribute(IntegerAttributeCallback callback) { readBitmap8Attribute(chipClusterPtr, callback); } + public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value) { writeBitmap8Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeBitmap8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap8Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap16Attribute( - IntegerAttributeCallback callback - ) { + public void readBitmap16Attribute(IntegerAttributeCallback callback) { readBitmap16Attribute(chipClusterPtr, callback); } + public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value) { writeBitmap16Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeBitmap16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap16Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap32Attribute( - LongAttributeCallback callback - ) { + public void readBitmap32Attribute(LongAttributeCallback callback) { readBitmap32Attribute(chipClusterPtr, callback); } + public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value) { writeBitmap32Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBitmap32Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap32Attribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBitmap64Attribute( - LongAttributeCallback callback - ) { + public void readBitmap64Attribute(LongAttributeCallback callback) { readBitmap64Attribute(chipClusterPtr, callback); } + public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value) { writeBitmap64Attribute(chipClusterPtr, callback, value, null); } - public void writeBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeBitmap64Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeBitmap64Attribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt8uAttribute( - IntegerAttributeCallback callback - ) { + public void readInt8uAttribute(IntegerAttributeCallback callback) { readInt8uAttribute(chipClusterPtr, callback); } + public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt8uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt16uAttribute( - IntegerAttributeCallback callback - ) { + public void readInt16uAttribute(IntegerAttributeCallback callback) { readInt16uAttribute(chipClusterPtr, callback); } + public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt16uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt24uAttribute( - LongAttributeCallback callback - ) { + public void readInt24uAttribute(LongAttributeCallback callback) { readInt24uAttribute(chipClusterPtr, callback); } + public void writeInt24uAttribute(DefaultClusterCallback callback, Long value) { writeInt24uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt24uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt24uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt32uAttribute( - LongAttributeCallback callback - ) { + public void readInt32uAttribute(LongAttributeCallback callback) { readInt32uAttribute(chipClusterPtr, callback); } + public void writeInt32uAttribute(DefaultClusterCallback callback, Long value) { writeInt32uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt32uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt32uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt40uAttribute( - LongAttributeCallback callback - ) { + public void readInt40uAttribute(LongAttributeCallback callback) { readInt40uAttribute(chipClusterPtr, callback); } + public void writeInt40uAttribute(DefaultClusterCallback callback, Long value) { writeInt40uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt40uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt40uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt48uAttribute( - LongAttributeCallback callback - ) { + public void readInt48uAttribute(LongAttributeCallback callback) { readInt48uAttribute(chipClusterPtr, callback); } + public void writeInt48uAttribute(DefaultClusterCallback callback, Long value) { writeInt48uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt48uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt48uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt56uAttribute( - LongAttributeCallback callback - ) { + public void readInt56uAttribute(LongAttributeCallback callback) { readInt56uAttribute(chipClusterPtr, callback); } + public void writeInt56uAttribute(DefaultClusterCallback callback, Long value) { writeInt56uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt56uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt56uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt64uAttribute( - LongAttributeCallback callback - ) { + public void readInt64uAttribute(LongAttributeCallback callback) { readInt64uAttribute(chipClusterPtr, callback); } + public void writeInt64uAttribute(DefaultClusterCallback callback, Long value) { writeInt64uAttribute(chipClusterPtr, callback, value, null); } - public void writeInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt64uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt64uAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt8sAttribute( - IntegerAttributeCallback callback - ) { + public void readInt8sAttribute(IntegerAttributeCallback callback) { readInt8sAttribute(chipClusterPtr, callback); } + public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt8sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt16sAttribute( - IntegerAttributeCallback callback - ) { + public void readInt16sAttribute(IntegerAttributeCallback callback) { readInt16sAttribute(chipClusterPtr, callback); } + public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt16sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt24sAttribute( - LongAttributeCallback callback - ) { + public void readInt24sAttribute(LongAttributeCallback callback) { readInt24sAttribute(chipClusterPtr, callback); } + public void writeInt24sAttribute(DefaultClusterCallback callback, Long value) { writeInt24sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt24sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt24sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt32sAttribute( - LongAttributeCallback callback - ) { + public void readInt32sAttribute(LongAttributeCallback callback) { readInt32sAttribute(chipClusterPtr, callback); } + public void writeInt32sAttribute(DefaultClusterCallback callback, Long value) { writeInt32sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt32sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt32sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt40sAttribute( - LongAttributeCallback callback - ) { + public void readInt40sAttribute(LongAttributeCallback callback) { readInt40sAttribute(chipClusterPtr, callback); } + public void writeInt40sAttribute(DefaultClusterCallback callback, Long value) { writeInt40sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt40sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt40sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt48sAttribute( - LongAttributeCallback callback - ) { + public void readInt48sAttribute(LongAttributeCallback callback) { readInt48sAttribute(chipClusterPtr, callback); } + public void writeInt48sAttribute(DefaultClusterCallback callback, Long value) { writeInt48sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt48sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt48sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt56sAttribute( - LongAttributeCallback callback - ) { + public void readInt56sAttribute(LongAttributeCallback callback) { readInt56sAttribute(chipClusterPtr, callback); } + public void writeInt56sAttribute(DefaultClusterCallback callback, Long value) { writeInt56sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt56sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt56sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInt64sAttribute( - LongAttributeCallback callback - ) { + public void readInt64sAttribute(LongAttributeCallback callback) { readInt64sAttribute(chipClusterPtr, callback); } + public void writeInt64sAttribute(DefaultClusterCallback callback, Long value) { writeInt64sAttribute(chipClusterPtr, callback, value, null); } - public void writeInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeInt64sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeInt64sAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnum8Attribute( - IntegerAttributeCallback callback - ) { + public void readEnum8Attribute(IntegerAttributeCallback callback) { readEnum8Attribute(chipClusterPtr, callback); } + public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value) { writeEnum8Attribute(chipClusterPtr, callback, value, null); } - public void writeEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnum8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnum8Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnum16Attribute( - IntegerAttributeCallback callback - ) { + public void readEnum16Attribute(IntegerAttributeCallback callback) { readEnum16Attribute(chipClusterPtr, callback); } + public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value) { writeEnum16Attribute(chipClusterPtr, callback, value, null); } - public void writeEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnum16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnum16Attribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFloatSingleAttribute( - FloatAttributeCallback callback - ) { + public void readFloatSingleAttribute(FloatAttributeCallback callback) { readFloatSingleAttribute(chipClusterPtr, callback); } + public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value) { writeFloatSingleAttribute(chipClusterPtr, callback, value, null); } - public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + public void writeFloatSingleAttribute( + DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { writeFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeFloatSingleAttribute( - FloatAttributeCallback callback -, - int minInterval, int maxInterval) { + FloatAttributeCallback callback, int minInterval, int maxInterval) { subscribeFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFloatDoubleAttribute( - DoubleAttributeCallback callback - ) { + public void readFloatDoubleAttribute(DoubleAttributeCallback callback) { readFloatDoubleAttribute(chipClusterPtr, callback); } + public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { writeFloatDoubleAttribute(chipClusterPtr, callback, value, null); } - public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + public void writeFloatDoubleAttribute( + DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { writeFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeFloatDoubleAttribute( - DoubleAttributeCallback callback -, - int minInterval, int maxInterval) { + DoubleAttributeCallback callback, int minInterval, int maxInterval) { subscribeFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOctetStringAttribute( - OctetStringAttributeCallback callback - ) { + public void readOctetStringAttribute(OctetStringAttributeCallback callback) { readOctetStringAttribute(chipClusterPtr, callback); } + public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeOctetStringAttribute( + DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOctetStringAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListInt8uAttribute( - ListInt8uAttributeCallback callback - ) { + public void readListInt8uAttribute(ListInt8uAttributeCallback callback) { readListInt8uAttribute(chipClusterPtr, callback); } + public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value) { writeListInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeListInt8uAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListInt8uAttribute( + DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListInt8uAttribute( - ListInt8uAttributeCallback callback - , - int minInterval, int maxInterval) { + ListInt8uAttributeCallback callback, int minInterval, int maxInterval) { subscribeListInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListOctetStringAttribute( - ListOctetStringAttributeCallback callback - ) { + public void readListOctetStringAttribute(ListOctetStringAttributeCallback callback) { readListOctetStringAttribute(chipClusterPtr, callback); } - public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeListOctetStringAttribute( + DefaultClusterCallback callback, ArrayList value) { writeListOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeListOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListOctetStringAttribute( + DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { writeListOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListOctetStringAttribute( - ListOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + ListOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeListOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readListStructOctetStringAttribute( - ListStructOctetStringAttributeCallback callback - ) { + ListStructOctetStringAttributeCallback callback) { readListStructOctetStringAttribute(chipClusterPtr, callback); } - public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeListStructOctetStringAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeListStructOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeListStructOctetStringAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeListStructOctetStringAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeListStructOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListStructOctetStringAttribute( - ListStructOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + ListStructOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeListStructOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLongOctetStringAttribute( - OctetStringAttributeCallback callback - ) { + public void readLongOctetStringAttribute(OctetStringAttributeCallback callback) { readLongOctetStringAttribute(chipClusterPtr, callback); } + public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeLongOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeLongOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeLongOctetStringAttribute( + DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeLongOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLongOctetStringAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCharStringAttribute( - CharStringAttributeCallback callback - ) { + public void readCharStringAttribute(CharStringAttributeCallback callback) { readCharStringAttribute(chipClusterPtr, callback); } + public void writeCharStringAttribute(DefaultClusterCallback callback, String value) { writeCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeCharStringAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeCharStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLongCharStringAttribute( - CharStringAttributeCallback callback - ) { + public void readLongCharStringAttribute(CharStringAttributeCallback callback) { readLongCharStringAttribute(chipClusterPtr, callback); } + public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value) { writeLongCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeLongCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeLongCharStringAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeLongCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLongCharStringAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeLongCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEpochUsAttribute( - LongAttributeCallback callback - ) { + public void readEpochUsAttribute(LongAttributeCallback callback) { readEpochUsAttribute(chipClusterPtr, callback); } + public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value) { writeEpochUsAttribute(chipClusterPtr, callback, value, null); } - public void writeEpochUsAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeEpochUsAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeEpochUsAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEpochUsAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeEpochUsAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readEpochSAttribute( - LongAttributeCallback callback - ) { + public void readEpochSAttribute(LongAttributeCallback callback) { readEpochSAttribute(chipClusterPtr, callback); } + public void writeEpochSAttribute(DefaultClusterCallback callback, Long value) { writeEpochSAttribute(chipClusterPtr, callback, value, null); } - public void writeEpochSAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeEpochSAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeEpochSAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEpochSAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeEpochSAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readVendorIdAttribute( - VendorIdAttributeCallback callback - ) { + public void readVendorIdAttribute(VendorIdAttributeCallback callback) { readVendorIdAttribute(chipClusterPtr, callback); } + public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value) { writeVendorIdAttribute(chipClusterPtr, callback, value, null); } - public void writeVendorIdAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeVendorIdAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeVendorIdAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeVendorIdAttribute( - VendorIdAttributeCallback callback - , - int minInterval, int maxInterval) { + VendorIdAttributeCallback callback, int minInterval, int maxInterval) { subscribeVendorIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readListNullablesAndOptionalsStructAttribute( - ListNullablesAndOptionalsStructAttributeCallback callback - ) { + ListNullablesAndOptionalsStructAttributeCallback callback) { readListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback); } - public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeListNullablesAndOptionalsStructAttribute( + DefaultClusterCallback callback, + ArrayList value) { writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, null); } - public void writeListNullablesAndOptionalsStructAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { - writeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeListNullablesAndOptionalsStructAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { + writeListNullablesAndOptionalsStructAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeListNullablesAndOptionalsStructAttribute( - ListNullablesAndOptionalsStructAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeListNullablesAndOptionalsStructAttribute(chipClusterPtr, callback, minInterval, maxInterval); + ListNullablesAndOptionalsStructAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeListNullablesAndOptionalsStructAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readEnumAttrAttribute( - IntegerAttributeCallback callback - ) { + public void readEnumAttrAttribute(IntegerAttributeCallback callback) { readEnumAttrAttribute(chipClusterPtr, callback); } + public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { writeEnumAttrAttribute(chipClusterPtr, callback, value, null); } - public void writeEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeEnumAttrAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeEnumAttrAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt8uAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt8uAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt8uAttribute(chipClusterPtr, callback); } + public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt8uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt8sAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt8sAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt8sAttribute(chipClusterPtr, callback); } + public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt8sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt16uAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt16uAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt16uAttribute(chipClusterPtr, callback); } - public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt16uAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRangeRestrictedInt16sAttribute( - IntegerAttributeCallback callback - ) { + public void readRangeRestrictedInt16sAttribute(IntegerAttributeCallback callback) { readRangeRestrictedInt16sAttribute(chipClusterPtr, callback); } - public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value) { writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeRangeRestrictedInt16sAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readListLongOctetStringAttribute( - ListLongOctetStringAttributeCallback callback - ) { + public void readListLongOctetStringAttribute(ListLongOctetStringAttributeCallback callback) { readListLongOctetStringAttribute(chipClusterPtr, callback); } + public void subscribeListLongOctetStringAttribute( - ListLongOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + ListLongOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeListLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTimedWriteBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readTimedWriteBooleanAttribute(BooleanAttributeCallback callback) { readTimedWriteBooleanAttribute(chipClusterPtr, callback); } - public void writeTimedWriteBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeTimedWriteBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeTimedWriteBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeTimedWriteBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeTimedWriteBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readGeneralErrorBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readGeneralErrorBooleanAttribute(BooleanAttributeCallback callback) { readGeneralErrorBooleanAttribute(chipClusterPtr, callback); } + public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeGeneralErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeGeneralErrorBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeGeneralErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeGeneralErrorBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeGeneralErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterErrorBooleanAttribute( - BooleanAttributeCallback callback - ) { + public void readClusterErrorBooleanAttribute(BooleanAttributeCallback callback) { readClusterErrorBooleanAttribute(chipClusterPtr, callback); } + public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeClusterErrorBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeClusterErrorBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeClusterErrorBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeClusterErrorBooleanAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterErrorBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readUnsupportedAttribute( - BooleanAttributeCallback callback - ) { + public void readUnsupportedAttribute(BooleanAttributeCallback callback) { readUnsupportedAttribute(chipClusterPtr, callback); } + public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value) { writeUnsupportedAttribute(chipClusterPtr, callback, value, null); } - public void writeUnsupportedAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeUnsupportedAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeUnsupportedAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeUnsupportedAttribute( - BooleanAttributeCallback callback -, - int minInterval, int maxInterval) { + BooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeUnsupportedAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBooleanAttribute( - NullableBooleanAttributeCallback callback - ) { + public void readNullableBooleanAttribute(NullableBooleanAttributeCallback callback) { readNullableBooleanAttribute(chipClusterPtr, callback); } + public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value) { writeNullableBooleanAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableBooleanAttribute(DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { + public void writeNullableBooleanAttribute( + DefaultClusterCallback callback, Boolean value, int timedWriteTimeoutMs) { writeNullableBooleanAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBooleanAttribute( - NullableBooleanAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBooleanAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBooleanAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap8Attribute( - NullableBitmap8AttributeCallback callback - ) { + public void readNullableBitmap8Attribute(NullableBitmap8AttributeCallback callback) { readNullableBitmap8Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value) { writeNullableBitmap8Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableBitmap8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableBitmap8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap8Attribute( - NullableBitmap8AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap8AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap16Attribute( - NullableBitmap16AttributeCallback callback - ) { + public void readNullableBitmap16Attribute(NullableBitmap16AttributeCallback callback) { readNullableBitmap16Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value) { writeNullableBitmap16Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableBitmap16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableBitmap16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap16Attribute( - NullableBitmap16AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap16AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap32Attribute( - NullableBitmap32AttributeCallback callback - ) { + public void readNullableBitmap32Attribute(NullableBitmap32AttributeCallback callback) { readNullableBitmap32Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value) { writeNullableBitmap32Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap32Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableBitmap32Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableBitmap32Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap32Attribute( - NullableBitmap32AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap32AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap32Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableBitmap64Attribute( - NullableBitmap64AttributeCallback callback - ) { + public void readNullableBitmap64Attribute(NullableBitmap64AttributeCallback callback) { readNullableBitmap64Attribute(chipClusterPtr, callback); } + public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value) { writeNullableBitmap64Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableBitmap64Attribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableBitmap64Attribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableBitmap64Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableBitmap64Attribute( - NullableBitmap64AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableBitmap64AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableBitmap64Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt8uAttribute( - NullableInt8uAttributeCallback callback - ) { + public void readNullableInt8uAttribute(NullableInt8uAttributeCallback callback) { readNullableInt8uAttribute(chipClusterPtr, callback); } + public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt8uAttribute( - NullableInt8uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt8uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt16uAttribute( - NullableInt16uAttributeCallback callback - ) { + public void readNullableInt16uAttribute(NullableInt16uAttributeCallback callback) { readNullableInt16uAttribute(chipClusterPtr, callback); } + public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt16uAttribute( - NullableInt16uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt16uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt24uAttribute( - NullableInt24uAttributeCallback callback - ) { + public void readNullableInt24uAttribute(NullableInt24uAttributeCallback callback) { readNullableInt24uAttribute(chipClusterPtr, callback); } + public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt24uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt24uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt24uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt24uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt24uAttribute( - NullableInt24uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt24uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt24uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt32uAttribute( - NullableInt32uAttributeCallback callback - ) { + public void readNullableInt32uAttribute(NullableInt32uAttributeCallback callback) { readNullableInt32uAttribute(chipClusterPtr, callback); } + public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt32uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt32uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt32uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt32uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt32uAttribute( - NullableInt32uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt32uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt32uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt40uAttribute( - NullableInt40uAttributeCallback callback - ) { + public void readNullableInt40uAttribute(NullableInt40uAttributeCallback callback) { readNullableInt40uAttribute(chipClusterPtr, callback); } + public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt40uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt40uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt40uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt40uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt40uAttribute( - NullableInt40uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt40uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt40uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt48uAttribute( - NullableInt48uAttributeCallback callback - ) { + public void readNullableInt48uAttribute(NullableInt48uAttributeCallback callback) { readNullableInt48uAttribute(chipClusterPtr, callback); } + public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt48uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt48uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt48uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt48uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt48uAttribute( - NullableInt48uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt48uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt48uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt56uAttribute( - NullableInt56uAttributeCallback callback - ) { + public void readNullableInt56uAttribute(NullableInt56uAttributeCallback callback) { readNullableInt56uAttribute(chipClusterPtr, callback); } + public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt56uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt56uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt56uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt56uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt56uAttribute( - NullableInt56uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt56uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt56uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt64uAttribute( - NullableInt64uAttributeCallback callback - ) { + public void readNullableInt64uAttribute(NullableInt64uAttributeCallback callback) { readNullableInt64uAttribute(chipClusterPtr, callback); } + public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt64uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt64uAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt64uAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt64uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt64uAttribute( - NullableInt64uAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt64uAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt64uAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt8sAttribute( - NullableInt8sAttributeCallback callback - ) { + public void readNullableInt8sAttribute(NullableInt8sAttributeCallback callback) { readNullableInt8sAttribute(chipClusterPtr, callback); } + public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt8sAttribute( - NullableInt8sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt8sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt16sAttribute( - NullableInt16sAttributeCallback callback - ) { + public void readNullableInt16sAttribute(NullableInt16sAttributeCallback callback) { readNullableInt16sAttribute(chipClusterPtr, callback); } + public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value) { writeNullableInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt16sAttribute( - NullableInt16sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt16sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt24sAttribute( - NullableInt24sAttributeCallback callback - ) { + public void readNullableInt24sAttribute(NullableInt24sAttributeCallback callback) { readNullableInt24sAttribute(chipClusterPtr, callback); } + public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt24sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt24sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt24sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt24sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt24sAttribute( - NullableInt24sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt24sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt24sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt32sAttribute( - NullableInt32sAttributeCallback callback - ) { + public void readNullableInt32sAttribute(NullableInt32sAttributeCallback callback) { readNullableInt32sAttribute(chipClusterPtr, callback); } + public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt32sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt32sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt32sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt32sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt32sAttribute( - NullableInt32sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt32sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt32sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt40sAttribute( - NullableInt40sAttributeCallback callback - ) { + public void readNullableInt40sAttribute(NullableInt40sAttributeCallback callback) { readNullableInt40sAttribute(chipClusterPtr, callback); } + public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt40sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt40sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt40sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt40sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt40sAttribute( - NullableInt40sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt40sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt40sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt48sAttribute( - NullableInt48sAttributeCallback callback - ) { + public void readNullableInt48sAttribute(NullableInt48sAttributeCallback callback) { readNullableInt48sAttribute(chipClusterPtr, callback); } + public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt48sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt48sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt48sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt48sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt48sAttribute( - NullableInt48sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt48sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt48sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt56sAttribute( - NullableInt56sAttributeCallback callback - ) { + public void readNullableInt56sAttribute(NullableInt56sAttributeCallback callback) { readNullableInt56sAttribute(chipClusterPtr, callback); } + public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt56sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt56sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt56sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt56sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt56sAttribute( - NullableInt56sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt56sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt56sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableInt64sAttribute( - NullableInt64sAttributeCallback callback - ) { + public void readNullableInt64sAttribute(NullableInt64sAttributeCallback callback) { readNullableInt64sAttribute(chipClusterPtr, callback); } + public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value) { writeNullableInt64sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableInt64sAttribute(DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { + public void writeNullableInt64sAttribute( + DefaultClusterCallback callback, Long value, int timedWriteTimeoutMs) { writeNullableInt64sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableInt64sAttribute( - NullableInt64sAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableInt64sAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableInt64sAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnum8Attribute( - NullableEnum8AttributeCallback callback - ) { + public void readNullableEnum8Attribute(NullableEnum8AttributeCallback callback) { readNullableEnum8Attribute(chipClusterPtr, callback); } + public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value) { writeNullableEnum8Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnum8Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnum8Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnum8Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableEnum8Attribute( - NullableEnum8AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableEnum8AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableEnum8Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnum16Attribute( - NullableEnum16AttributeCallback callback - ) { + public void readNullableEnum16Attribute(NullableEnum16AttributeCallback callback) { readNullableEnum16Attribute(chipClusterPtr, callback); } + public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value) { writeNullableEnum16Attribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnum16Attribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnum16Attribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnum16Attribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableEnum16Attribute( - NullableEnum16AttributeCallback callback - , - int minInterval, int maxInterval) { + NullableEnum16AttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableEnum16Attribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableFloatSingleAttribute( - NullableFloatSingleAttributeCallback callback - ) { + public void readNullableFloatSingleAttribute(NullableFloatSingleAttributeCallback callback) { readNullableFloatSingleAttribute(chipClusterPtr, callback); } + public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value) { writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableFloatSingleAttribute(DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { + public void writeNullableFloatSingleAttribute( + DefaultClusterCallback callback, Float value, int timedWriteTimeoutMs) { writeNullableFloatSingleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableFloatSingleAttribute( - NullableFloatSingleAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableFloatSingleAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableFloatDoubleAttribute( - NullableFloatDoubleAttributeCallback callback - ) { + public void readNullableFloatDoubleAttribute(NullableFloatDoubleAttributeCallback callback) { readNullableFloatDoubleAttribute(chipClusterPtr, callback); } + public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableFloatDoubleAttribute(DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { + public void writeNullableFloatDoubleAttribute( + DefaultClusterCallback callback, Double value, int timedWriteTimeoutMs) { writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableFloatDoubleAttribute( - NullableFloatDoubleAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableFloatDoubleAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableOctetStringAttribute( - NullableOctetStringAttributeCallback callback - ) { + public void readNullableOctetStringAttribute(NullableOctetStringAttributeCallback callback) { readNullableOctetStringAttribute(chipClusterPtr, callback); } + public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value) { writeNullableOctetStringAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableOctetStringAttribute(DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { + public void writeNullableOctetStringAttribute( + DefaultClusterCallback callback, byte[] value, int timedWriteTimeoutMs) { writeNullableOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableOctetStringAttribute( - NullableOctetStringAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableCharStringAttribute( - NullableCharStringAttributeCallback callback - ) { + public void readNullableCharStringAttribute(NullableCharStringAttributeCallback callback) { readNullableCharStringAttribute(chipClusterPtr, callback); } + public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value) { writeNullableCharStringAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableCharStringAttribute(DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { + public void writeNullableCharStringAttribute( + DefaultClusterCallback callback, String value, int timedWriteTimeoutMs) { writeNullableCharStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableCharStringAttribute( - NullableCharStringAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableCharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableCharStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNullableEnumAttrAttribute( - NullableEnumAttrAttributeCallback callback - ) { + public void readNullableEnumAttrAttribute(NullableEnumAttrAttributeCallback callback) { readNullableEnumAttrAttribute(chipClusterPtr, callback); } + public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value) { writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableEnumAttrAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeNullableEnumAttrAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeNullableEnumAttrAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableEnumAttrAttribute( - NullableEnumAttrAttributeCallback callback - , - int minInterval, int maxInterval) { + NullableEnumAttrAttributeCallback callback, int minInterval, int maxInterval) { subscribeNullableEnumAttrAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt8uAttribute( - NullableRangeRestrictedInt8uAttributeCallback callback - ) { + NullableRangeRestrictedInt8uAttributeCallback callback) { readNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt8uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt8uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8uAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt8uAttribute( - NullableRangeRestrictedInt8uAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt8uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt8uAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8uAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt8sAttribute( - NullableRangeRestrictedInt8sAttributeCallback callback - ) { + NullableRangeRestrictedInt8sAttributeCallback callback) { readNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt8sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt8sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt8sAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt8sAttribute( - NullableRangeRestrictedInt8sAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt8sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt8sAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt8sAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt16uAttribute( - NullableRangeRestrictedInt16uAttributeCallback callback - ) { + NullableRangeRestrictedInt16uAttributeCallback callback) { readNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt16uAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt16uAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16uAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt16uAttribute( - NullableRangeRestrictedInt16uAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt16uAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt16uAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16uAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readNullableRangeRestrictedInt16sAttribute( - NullableRangeRestrictedInt16sAttributeCallback callback - ) { + NullableRangeRestrictedInt16sAttributeCallback callback) { readNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback); } - public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeNullableRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value) { writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, null); } - public void writeNullableRangeRestrictedInt16sAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeNullableRangeRestrictedInt16sAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeNullableRangeRestrictedInt16sAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeNullableRangeRestrictedInt16sAttribute( - NullableRangeRestrictedInt16sAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeNullableRangeRestrictedInt16sAttribute(chipClusterPtr, callback, minInterval, maxInterval); + NullableRangeRestrictedInt16sAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNullableRangeRestrictedInt16sAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap32Attribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap32Attribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBitmap64Attribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeBitmap64Attribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt24uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt24uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt32uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt32uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt40uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt40uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt48uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt48uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt56uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt56uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt64uAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt64uAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt24sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt24sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt32sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt32sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt40sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt40sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt48sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt48sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt56sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt56sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInt64sAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeInt64sAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnum8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnum8Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEnum16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnum16Attribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readFloatSingleAttribute(long chipClusterPtr, - FloatAttributeCallback callback - ); - - private native void writeFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeFloatSingleAttribute(long chipClusterPtr, - FloatAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readFloatDoubleAttribute(long chipClusterPtr, - DoubleAttributeCallback callback - ); - - private native void writeFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeFloatDoubleAttribute(long chipClusterPtr, - DoubleAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - - private native void writeOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readListInt8uAttribute(long chipClusterPtr, - ListInt8uAttributeCallback callback - ); - - private native void writeListInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListInt8uAttribute(long chipClusterPtr, - ListInt8uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readListOctetStringAttribute(long chipClusterPtr, - ListOctetStringAttributeCallback callback - ); - - private native void writeListOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListOctetStringAttribute(long chipClusterPtr, - ListOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readListStructOctetStringAttribute(long chipClusterPtr, - ListStructOctetStringAttributeCallback callback - ); - - private native void writeListStructOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListStructOctetStringAttribute(long chipClusterPtr, - ListStructOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readLongOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - - private native void writeLongOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLongOctetStringAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLongCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - - private native void writeLongCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLongCharStringAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEpochUsAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeEpochUsAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEpochUsAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readEpochSAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - - private native void writeEpochSAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEpochSAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readVendorIdAttribute(long chipClusterPtr, - VendorIdAttributeCallback callback - ); - - private native void writeVendorIdAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeVendorIdAttribute(long chipClusterPtr, - VendorIdAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readListNullablesAndOptionalsStructAttribute(long chipClusterPtr, - ListNullablesAndOptionalsStructAttributeCallback callback - ); - - private native void writeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeListNullablesAndOptionalsStructAttribute(long chipClusterPtr, - ListNullablesAndOptionalsStructAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readEnumAttrAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeEnumAttrAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt8uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt8sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt16uAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRangeRestrictedInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeRangeRestrictedInt16sAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readListLongOctetStringAttribute(long chipClusterPtr, - ListLongOctetStringAttributeCallback callback - ); - private native void subscribeListLongOctetStringAttribute(long chipClusterPtr, - ListLongOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readTimedWriteBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeTimedWriteBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeTimedWriteBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readGeneralErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeGeneralErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeGeneralErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readClusterErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeClusterErrorBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeClusterErrorBooleanAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readUnsupportedAttribute(long chipClusterPtr, - BooleanAttributeCallback callback - ); - - private native void writeUnsupportedAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeUnsupportedAttribute(long chipClusterPtr, - BooleanAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNullableBooleanAttribute(long chipClusterPtr, - NullableBooleanAttributeCallback callback - ); - - private native void writeNullableBooleanAttribute(long chipClusterPtr, DefaultClusterCallback callback, Boolean value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBooleanAttribute(long chipClusterPtr, - NullableBooleanAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap8Attribute(long chipClusterPtr, - NullableBitmap8AttributeCallback callback - ); - - private native void writeNullableBitmap8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap8Attribute(long chipClusterPtr, - NullableBitmap8AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap16Attribute(long chipClusterPtr, - NullableBitmap16AttributeCallback callback - ); - - private native void writeNullableBitmap16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap16Attribute(long chipClusterPtr, - NullableBitmap16AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap32Attribute(long chipClusterPtr, - NullableBitmap32AttributeCallback callback - ); - - private native void writeNullableBitmap32Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap32Attribute(long chipClusterPtr, - NullableBitmap32AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableBitmap64Attribute(long chipClusterPtr, - NullableBitmap64AttributeCallback callback - ); - - private native void writeNullableBitmap64Attribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableBitmap64Attribute(long chipClusterPtr, - NullableBitmap64AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt8uAttribute(long chipClusterPtr, - NullableInt8uAttributeCallback callback - ); - - private native void writeNullableInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt8uAttribute(long chipClusterPtr, - NullableInt8uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt16uAttribute(long chipClusterPtr, - NullableInt16uAttributeCallback callback - ); - - private native void writeNullableInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt16uAttribute(long chipClusterPtr, - NullableInt16uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt24uAttribute(long chipClusterPtr, - NullableInt24uAttributeCallback callback - ); - - private native void writeNullableInt24uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt24uAttribute(long chipClusterPtr, - NullableInt24uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt32uAttribute(long chipClusterPtr, - NullableInt32uAttributeCallback callback - ); - - private native void writeNullableInt32uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt32uAttribute(long chipClusterPtr, - NullableInt32uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt40uAttribute(long chipClusterPtr, - NullableInt40uAttributeCallback callback - ); - - private native void writeNullableInt40uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt40uAttribute(long chipClusterPtr, - NullableInt40uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt48uAttribute(long chipClusterPtr, - NullableInt48uAttributeCallback callback - ); - - private native void writeNullableInt48uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt48uAttribute(long chipClusterPtr, - NullableInt48uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt56uAttribute(long chipClusterPtr, - NullableInt56uAttributeCallback callback - ); - - private native void writeNullableInt56uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt56uAttribute(long chipClusterPtr, - NullableInt56uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt64uAttribute(long chipClusterPtr, - NullableInt64uAttributeCallback callback - ); - - private native void writeNullableInt64uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt64uAttribute(long chipClusterPtr, - NullableInt64uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt8sAttribute(long chipClusterPtr, - NullableInt8sAttributeCallback callback - ); - - private native void writeNullableInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt8sAttribute(long chipClusterPtr, - NullableInt8sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt16sAttribute(long chipClusterPtr, - NullableInt16sAttributeCallback callback - ); - - private native void writeNullableInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt16sAttribute(long chipClusterPtr, - NullableInt16sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt24sAttribute(long chipClusterPtr, - NullableInt24sAttributeCallback callback - ); - - private native void writeNullableInt24sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt24sAttribute(long chipClusterPtr, - NullableInt24sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt32sAttribute(long chipClusterPtr, - NullableInt32sAttributeCallback callback - ); - - private native void writeNullableInt32sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt32sAttribute(long chipClusterPtr, - NullableInt32sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt40sAttribute(long chipClusterPtr, - NullableInt40sAttributeCallback callback - ); - - private native void writeNullableInt40sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt40sAttribute(long chipClusterPtr, - NullableInt40sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt48sAttribute(long chipClusterPtr, - NullableInt48sAttributeCallback callback - ); - - private native void writeNullableInt48sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt48sAttribute(long chipClusterPtr, - NullableInt48sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt56sAttribute(long chipClusterPtr, - NullableInt56sAttributeCallback callback - ); - - private native void writeNullableInt56sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt56sAttribute(long chipClusterPtr, - NullableInt56sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableInt64sAttribute(long chipClusterPtr, - NullableInt64sAttributeCallback callback - ); - - private native void writeNullableInt64sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Long value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableInt64sAttribute(long chipClusterPtr, - NullableInt64sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableEnum8Attribute(long chipClusterPtr, - NullableEnum8AttributeCallback callback - ); - - private native void writeNullableEnum8Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableEnum8Attribute(long chipClusterPtr, - NullableEnum8AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableEnum16Attribute(long chipClusterPtr, - NullableEnum16AttributeCallback callback - ); - - private native void writeNullableEnum16Attribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableEnum16Attribute(long chipClusterPtr, - NullableEnum16AttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableFloatSingleAttribute(long chipClusterPtr, - NullableFloatSingleAttributeCallback callback - ); - - private native void writeNullableFloatSingleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Float value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableFloatSingleAttribute(long chipClusterPtr, - NullableFloatSingleAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableFloatDoubleAttribute(long chipClusterPtr, - NullableFloatDoubleAttributeCallback callback - ); - - private native void writeNullableFloatDoubleAttribute(long chipClusterPtr, DefaultClusterCallback callback, Double value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableFloatDoubleAttribute(long chipClusterPtr, - NullableFloatDoubleAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableOctetStringAttribute(long chipClusterPtr, - NullableOctetStringAttributeCallback callback - ); - - private native void writeNullableOctetStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, byte[] value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableOctetStringAttribute(long chipClusterPtr, - NullableOctetStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableCharStringAttribute(long chipClusterPtr, - NullableCharStringAttributeCallback callback - ); - - private native void writeNullableCharStringAttribute(long chipClusterPtr, DefaultClusterCallback callback, String value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableCharStringAttribute(long chipClusterPtr, - NullableCharStringAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableEnumAttrAttribute(long chipClusterPtr, - NullableEnumAttrAttributeCallback callback - ); - - private native void writeNullableEnumAttrAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableEnumAttrAttribute(long chipClusterPtr, - NullableEnumAttrAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8uAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt8uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8sAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt8sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt8sAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16uAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt16uAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16uAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16sAttributeCallback callback - ); - - private native void writeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeNullableRangeRestrictedInt16sAttribute(long chipClusterPtr, - NullableRangeRestrictedInt16sAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap8Attribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeBitmap8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap8Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap16Attribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeBitmap16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap16Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap32Attribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeBitmap32Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap32Attribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBitmap64Attribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeBitmap64Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeBitmap64Attribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt8uAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt16uAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt24uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt24uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt24uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt32uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt32uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt32uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt40uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt40uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt40uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt48uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt48uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt48uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt56uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt56uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt56uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt64uAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt64uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt64uAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt8sAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt16sAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt24sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt24sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt24sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt32sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt32sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt32sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt40sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt40sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt40sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt48sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt48sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt48sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt56sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt56sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt56sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInt64sAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeInt64sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeInt64sAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnum8Attribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeEnum8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnum8Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEnum16Attribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeEnum16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnum16Attribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFloatSingleAttribute( + long chipClusterPtr, FloatAttributeCallback callback); + + private native void writeFloatSingleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Float value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeFloatSingleAttribute( + long chipClusterPtr, FloatAttributeCallback callback, int minInterval, int maxInterval); + + private native void readFloatDoubleAttribute( + long chipClusterPtr, DoubleAttributeCallback callback); + + private native void writeFloatDoubleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Double value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeFloatDoubleAttribute( + long chipClusterPtr, DoubleAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOctetStringAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void writeOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + byte[] value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOctetStringAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readListInt8uAttribute( + long chipClusterPtr, ListInt8uAttributeCallback callback); + + private native void writeListInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListInt8uAttribute( + long chipClusterPtr, ListInt8uAttributeCallback callback, int minInterval, int maxInterval); + + private native void readListOctetStringAttribute( + long chipClusterPtr, ListOctetStringAttributeCallback callback); + + private native void writeListOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListOctetStringAttribute( + long chipClusterPtr, + ListOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readListStructOctetStringAttribute( + long chipClusterPtr, ListStructOctetStringAttributeCallback callback); + + private native void writeListStructOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListStructOctetStringAttribute( + long chipClusterPtr, + ListStructOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLongOctetStringAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void writeLongOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + byte[] value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLongOctetStringAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCharStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeCharStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeCharStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readLongCharStringAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void writeLongCharStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeLongCharStringAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEpochUsAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeEpochUsAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEpochUsAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readEpochSAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void writeEpochSAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEpochSAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readVendorIdAttribute( + long chipClusterPtr, VendorIdAttributeCallback callback); + + private native void writeVendorIdAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeVendorIdAttribute( + long chipClusterPtr, VendorIdAttributeCallback callback, int minInterval, int maxInterval); + + private native void readListNullablesAndOptionalsStructAttribute( + long chipClusterPtr, ListNullablesAndOptionalsStructAttributeCallback callback); + + private native void writeListNullablesAndOptionalsStructAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeListNullablesAndOptionalsStructAttribute( + long chipClusterPtr, + ListNullablesAndOptionalsStructAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEnumAttrAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeEnumAttrAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeEnumAttrAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt8uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt8sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt16uAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRangeRestrictedInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeRangeRestrictedInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeRangeRestrictedInt16sAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readListLongOctetStringAttribute( + long chipClusterPtr, ListLongOctetStringAttributeCallback callback); + + private native void subscribeListLongOctetStringAttribute( + long chipClusterPtr, + ListLongOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readTimedWriteBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeTimedWriteBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeTimedWriteBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readGeneralErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeGeneralErrorBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeGeneralErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readClusterErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeClusterErrorBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeClusterErrorBooleanAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readUnsupportedAttribute( + long chipClusterPtr, BooleanAttributeCallback callback); + + private native void writeUnsupportedAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeUnsupportedAttribute( + long chipClusterPtr, BooleanAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNullableBooleanAttribute( + long chipClusterPtr, NullableBooleanAttributeCallback callback); + + private native void writeNullableBooleanAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Boolean value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBooleanAttribute( + long chipClusterPtr, + NullableBooleanAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap8Attribute( + long chipClusterPtr, NullableBitmap8AttributeCallback callback); + + private native void writeNullableBitmap8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap8Attribute( + long chipClusterPtr, + NullableBitmap8AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap16Attribute( + long chipClusterPtr, NullableBitmap16AttributeCallback callback); + + private native void writeNullableBitmap16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap16Attribute( + long chipClusterPtr, + NullableBitmap16AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap32Attribute( + long chipClusterPtr, NullableBitmap32AttributeCallback callback); + + private native void writeNullableBitmap32Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap32Attribute( + long chipClusterPtr, + NullableBitmap32AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableBitmap64Attribute( + long chipClusterPtr, NullableBitmap64AttributeCallback callback); + + private native void writeNullableBitmap64Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableBitmap64Attribute( + long chipClusterPtr, + NullableBitmap64AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt8uAttribute( + long chipClusterPtr, NullableInt8uAttributeCallback callback); + + private native void writeNullableInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt8uAttribute( + long chipClusterPtr, + NullableInt8uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt16uAttribute( + long chipClusterPtr, NullableInt16uAttributeCallback callback); + + private native void writeNullableInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt16uAttribute( + long chipClusterPtr, + NullableInt16uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt24uAttribute( + long chipClusterPtr, NullableInt24uAttributeCallback callback); + + private native void writeNullableInt24uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt24uAttribute( + long chipClusterPtr, + NullableInt24uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt32uAttribute( + long chipClusterPtr, NullableInt32uAttributeCallback callback); + + private native void writeNullableInt32uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt32uAttribute( + long chipClusterPtr, + NullableInt32uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt40uAttribute( + long chipClusterPtr, NullableInt40uAttributeCallback callback); + + private native void writeNullableInt40uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt40uAttribute( + long chipClusterPtr, + NullableInt40uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt48uAttribute( + long chipClusterPtr, NullableInt48uAttributeCallback callback); + + private native void writeNullableInt48uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt48uAttribute( + long chipClusterPtr, + NullableInt48uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt56uAttribute( + long chipClusterPtr, NullableInt56uAttributeCallback callback); + + private native void writeNullableInt56uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt56uAttribute( + long chipClusterPtr, + NullableInt56uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt64uAttribute( + long chipClusterPtr, NullableInt64uAttributeCallback callback); + + private native void writeNullableInt64uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt64uAttribute( + long chipClusterPtr, + NullableInt64uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt8sAttribute( + long chipClusterPtr, NullableInt8sAttributeCallback callback); + + private native void writeNullableInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt8sAttribute( + long chipClusterPtr, + NullableInt8sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt16sAttribute( + long chipClusterPtr, NullableInt16sAttributeCallback callback); + + private native void writeNullableInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt16sAttribute( + long chipClusterPtr, + NullableInt16sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt24sAttribute( + long chipClusterPtr, NullableInt24sAttributeCallback callback); + + private native void writeNullableInt24sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt24sAttribute( + long chipClusterPtr, + NullableInt24sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt32sAttribute( + long chipClusterPtr, NullableInt32sAttributeCallback callback); + + private native void writeNullableInt32sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt32sAttribute( + long chipClusterPtr, + NullableInt32sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt40sAttribute( + long chipClusterPtr, NullableInt40sAttributeCallback callback); + + private native void writeNullableInt40sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt40sAttribute( + long chipClusterPtr, + NullableInt40sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt48sAttribute( + long chipClusterPtr, NullableInt48sAttributeCallback callback); + + private native void writeNullableInt48sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt48sAttribute( + long chipClusterPtr, + NullableInt48sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt56sAttribute( + long chipClusterPtr, NullableInt56sAttributeCallback callback); + + private native void writeNullableInt56sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt56sAttribute( + long chipClusterPtr, + NullableInt56sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableInt64sAttribute( + long chipClusterPtr, NullableInt64sAttributeCallback callback); + + private native void writeNullableInt64sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Long value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableInt64sAttribute( + long chipClusterPtr, + NullableInt64sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableEnum8Attribute( + long chipClusterPtr, NullableEnum8AttributeCallback callback); + + private native void writeNullableEnum8Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableEnum8Attribute( + long chipClusterPtr, + NullableEnum8AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableEnum16Attribute( + long chipClusterPtr, NullableEnum16AttributeCallback callback); + + private native void writeNullableEnum16Attribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableEnum16Attribute( + long chipClusterPtr, + NullableEnum16AttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableFloatSingleAttribute( + long chipClusterPtr, NullableFloatSingleAttributeCallback callback); + + private native void writeNullableFloatSingleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Float value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableFloatSingleAttribute( + long chipClusterPtr, + NullableFloatSingleAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableFloatDoubleAttribute( + long chipClusterPtr, NullableFloatDoubleAttributeCallback callback); + + private native void writeNullableFloatDoubleAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Double value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableFloatDoubleAttribute( + long chipClusterPtr, + NullableFloatDoubleAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableOctetStringAttribute( + long chipClusterPtr, NullableOctetStringAttributeCallback callback); + + private native void writeNullableOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + byte[] value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableOctetStringAttribute( + long chipClusterPtr, + NullableOctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableCharStringAttribute( + long chipClusterPtr, NullableCharStringAttributeCallback callback); + + private native void writeNullableCharStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + String value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableCharStringAttribute( + long chipClusterPtr, + NullableCharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableEnumAttrAttribute( + long chipClusterPtr, NullableEnumAttrAttributeCallback callback); + + private native void writeNullableEnumAttrAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableEnumAttrAttribute( + long chipClusterPtr, + NullableEnumAttrAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, NullableRangeRestrictedInt8uAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt8uAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt8uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, NullableRangeRestrictedInt8sAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt8sAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt8sAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, NullableRangeRestrictedInt16uAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt16uAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt16uAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, NullableRangeRestrictedInt16sAttributeCallback callback); + + private native void writeNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeNullableRangeRestrictedInt16sAttribute( + long chipClusterPtr, + NullableRangeRestrictedInt16sAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class ThermostatCluster extends BaseChipCluster { @@ -14214,554 +15440,587 @@ public ThermostatCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void clearWeeklySchedule(DefaultClusterCallback callback - ) { + public void clearWeeklySchedule(DefaultClusterCallback callback) { clearWeeklySchedule(chipClusterPtr, callback, null); } - public void clearWeeklySchedule(DefaultClusterCallback callback + public void clearWeeklySchedule(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { clearWeeklySchedule(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback - ) { + public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback) { getRelayStatusLog(chipClusterPtr, callback, null); } - public void getRelayStatusLog(GetRelayStatusLogResponseCallback callback + public void getRelayStatusLog( + GetRelayStatusLogResponseCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { getRelayStatusLog(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback - , Integer daysToReturn, Integer modeToReturn) { + public void getWeeklySchedule( + GetWeeklyScheduleResponseCallback callback, Integer daysToReturn, Integer modeToReturn) { getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, null); } - public void getWeeklySchedule(GetWeeklyScheduleResponseCallback callback - , Integer daysToReturn, Integer modeToReturn - , int timedInvokeTimeoutMs) { + public void getWeeklySchedule( + GetWeeklyScheduleResponseCallback callback, + Integer daysToReturn, + Integer modeToReturn, + int timedInvokeTimeoutMs) { getWeeklySchedule(chipClusterPtr, callback, daysToReturn, modeToReturn, timedInvokeTimeoutMs); } - public void setWeeklySchedule(DefaultClusterCallback callback - , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload) { - setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, payload, null); - } - - public void setWeeklySchedule(DefaultClusterCallback callback - , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload - , int timedInvokeTimeoutMs) { - setWeeklySchedule(chipClusterPtr, callback, numberOfTransitionsForSequence, dayOfWeekForSequence, modeForSequence, payload, timedInvokeTimeoutMs); - } - - public void setpointRaiseLower(DefaultClusterCallback callback - , Integer mode, Integer amount) { + public void setWeeklySchedule( + DefaultClusterCallback callback, + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload) { + setWeeklySchedule( + chipClusterPtr, + callback, + numberOfTransitionsForSequence, + dayOfWeekForSequence, + modeForSequence, + payload, + null); + } + + public void setWeeklySchedule( + DefaultClusterCallback callback, + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload, + int timedInvokeTimeoutMs) { + setWeeklySchedule( + chipClusterPtr, + callback, + numberOfTransitionsForSequence, + dayOfWeekForSequence, + modeForSequence, + payload, + timedInvokeTimeoutMs); + } + + public void setpointRaiseLower(DefaultClusterCallback callback, Integer mode, Integer amount) { setpointRaiseLower(chipClusterPtr, callback, mode, amount, null); } - public void setpointRaiseLower(DefaultClusterCallback callback - , Integer mode, Integer amount - , int timedInvokeTimeoutMs) { + public void setpointRaiseLower( + DefaultClusterCallback callback, Integer mode, Integer amount, int timedInvokeTimeoutMs) { setpointRaiseLower(chipClusterPtr, callback, mode, amount, timedInvokeTimeoutMs); } - private native void clearWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void getRelayStatusLog(long chipClusterPtr, GetRelayStatusLogResponseCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void getWeeklySchedule(long chipClusterPtr, GetWeeklyScheduleResponseCallback Callback - , Integer daysToReturn, Integer modeToReturn - , @Nullable Integer timedInvokeTimeoutMs); - private native void setWeeklySchedule(long chipClusterPtr, DefaultClusterCallback Callback - , Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload - , @Nullable Integer timedInvokeTimeoutMs); - private native void setpointRaiseLower(long chipClusterPtr, DefaultClusterCallback Callback - , Integer mode, Integer amount - , @Nullable Integer timedInvokeTimeoutMs); + + private native void clearWeeklySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getRelayStatusLog( + long chipClusterPtr, + GetRelayStatusLogResponseCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void getWeeklySchedule( + long chipClusterPtr, + GetWeeklyScheduleResponseCallback Callback, + Integer daysToReturn, + Integer modeToReturn, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setWeeklySchedule( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload, + @Nullable Integer timedInvokeTimeoutMs); + + private native void setpointRaiseLower( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer mode, + Integer amount, + @Nullable Integer timedInvokeTimeoutMs); + public interface GetRelayStatusLogResponseCallback { - void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries); + void onSuccess( + Integer timeOfDay, + Integer relayStatus, + Integer localTemperature, + Integer humidityInPercentage, + Integer setpoint, + Integer unreadEntries); void onError(Exception error); } public interface GetWeeklyScheduleResponseCallback { - void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload); + void onSuccess( + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload); void onError(Exception error); } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readLocalTemperatureAttribute( - IntegerAttributeCallback callback - ) { + public void readLocalTemperatureAttribute(IntegerAttributeCallback callback) { readLocalTemperatureAttribute(chipClusterPtr, callback); } + public void subscribeLocalTemperatureAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLocalTemperatureAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMinHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMaxHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMinCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAbsMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readAbsMaxCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void subscribeAbsMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAbsMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupiedCoolingSetpointAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupiedCoolingSetpointAttribute(IntegerAttributeCallback callback) { readOccupiedCoolingSetpointAttribute(chipClusterPtr, callback); } - public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeOccupiedCoolingSetpointAttribute( + DefaultClusterCallback callback, Integer value) { writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, null); } - public void writeOccupiedCoolingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOccupiedCoolingSetpointAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOccupiedCoolingSetpointAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupiedCoolingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOccupiedHeatingSetpointAttribute( - IntegerAttributeCallback callback - ) { + public void readOccupiedHeatingSetpointAttribute(IntegerAttributeCallback callback) { readOccupiedHeatingSetpointAttribute(chipClusterPtr, callback); } - public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeOccupiedHeatingSetpointAttribute( + DefaultClusterCallback callback, Integer value) { writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, null); } - public void writeOccupiedHeatingSetpointAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeOccupiedHeatingSetpointAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeOccupiedHeatingSetpointAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOccupiedHeatingSetpointAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMinHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readMinHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMinHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinHeatSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMinHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxHeatSetpointLimitAttribute(IntegerAttributeCallback callback) { readMaxHeatSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMaxHeatSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMaxHeatSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMaxHeatSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxHeatSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMinCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readMinCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMinCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinCoolSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMinCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback - ) { + public void readMaxCoolSetpointLimitAttribute(IntegerAttributeCallback callback) { readMaxCoolSetpointLimitAttribute(chipClusterPtr, callback); } + public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value) { writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, null); } - public void writeMaxCoolSetpointLimitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMaxCoolSetpointLimitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMaxCoolSetpointLimitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMaxCoolSetpointLimitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMinSetpointDeadBandAttribute( - IntegerAttributeCallback callback - ) { + public void readMinSetpointDeadBandAttribute(IntegerAttributeCallback callback) { readMinSetpointDeadBandAttribute(chipClusterPtr, callback); } + public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value) { writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, null); } - public void writeMinSetpointDeadBandAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeMinSetpointDeadBandAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeMinSetpointDeadBandAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeMinSetpointDeadBandAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeMinSetpointDeadBandAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readControlSequenceOfOperationAttribute( - IntegerAttributeCallback callback - ) { + public void readControlSequenceOfOperationAttribute(IntegerAttributeCallback callback) { readControlSequenceOfOperationAttribute(chipClusterPtr, callback); } - public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeControlSequenceOfOperationAttribute( + DefaultClusterCallback callback, Integer value) { writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, null); } - public void writeControlSequenceOfOperationAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeControlSequenceOfOperationAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeControlSequenceOfOperationAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeControlSequenceOfOperationAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeControlSequenceOfOperationAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeControlSequenceOfOperationAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeControlSequenceOfOperationAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readSystemModeAttribute( - IntegerAttributeCallback callback - ) { + public void readSystemModeAttribute(IntegerAttributeCallback callback) { readSystemModeAttribute(chipClusterPtr, callback); } + public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value) { writeSystemModeAttribute(chipClusterPtr, callback, value, null); } - public void writeSystemModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeSystemModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeSystemModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeSystemModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSystemModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStartOfWeekAttribute( - IntegerAttributeCallback callback - ) { + public void readStartOfWeekAttribute(IntegerAttributeCallback callback) { readStartOfWeekAttribute(chipClusterPtr, callback); } + public void subscribeStartOfWeekAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStartOfWeekAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfWeeklyTransitionsAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfWeeklyTransitionsAttribute(IntegerAttributeCallback callback) { readNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfWeeklyTransitionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfWeeklyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfWeeklyTransitionsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readNumberOfDailyTransitionsAttribute( - IntegerAttributeCallback callback - ) { + public void readNumberOfDailyTransitionsAttribute(IntegerAttributeCallback callback) { readNumberOfDailyTransitionsAttribute(chipClusterPtr, callback); } + public void subscribeNumberOfDailyTransitionsAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeNumberOfDailyTransitionsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeNumberOfDailyTransitionsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLocalTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLocalTemperatureAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAbsMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupiedCoolingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOccupiedCoolingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOccupiedCoolingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOccupiedHeatingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeOccupiedHeatingSetpointAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeOccupiedHeatingSetpointAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMinHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMinHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMaxHeatSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMaxHeatSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMinCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMinCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMaxCoolSetpointLimitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMaxCoolSetpointLimitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMinSetpointDeadBandAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeMinSetpointDeadBandAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeMinSetpointDeadBandAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readControlSequenceOfOperationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeControlSequenceOfOperationAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeControlSequenceOfOperationAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSystemModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeSystemModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeSystemModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStartOfWeekAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStartOfWeekAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfWeeklyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNumberOfDailyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeNumberOfDailyTransitionsAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readLocalTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLocalTemperatureAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAbsMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAbsMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupiedCoolingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOccupiedCoolingSetpointAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOccupiedCoolingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOccupiedHeatingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeOccupiedHeatingSetpointAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeOccupiedHeatingSetpointAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMinHeatSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMinHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMaxHeatSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMaxHeatSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMinCoolSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMinCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMaxCoolSetpointLimitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMaxCoolSetpointLimitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMinSetpointDeadBandAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeMinSetpointDeadBandAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeMinSetpointDeadBandAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readControlSequenceOfOperationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeControlSequenceOfOperationAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeControlSequenceOfOperationAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSystemModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeSystemModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeSystemModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStartOfWeekAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStartOfWeekAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfWeeklyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfWeeklyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNumberOfDailyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeNumberOfDailyTransitionsAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 ThermostatUserInterfaceConfigurationCluster extends BaseChipCluster { @@ -14774,1443 +16033,1237 @@ public ThermostatUserInterfaceConfigurationCluster(long devicePtr, int endpointI @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readTemperatureDisplayModeAttribute( - IntegerAttributeCallback callback - ) { + public void readTemperatureDisplayModeAttribute(IntegerAttributeCallback callback) { readTemperatureDisplayModeAttribute(chipClusterPtr, callback); } - public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeTemperatureDisplayModeAttribute( + DefaultClusterCallback callback, Integer value) { writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, null); } - public void writeTemperatureDisplayModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeTemperatureDisplayModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeTemperatureDisplayModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeTemperatureDisplayModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeTemperatureDisplayModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readKeypadLockoutAttribute( - IntegerAttributeCallback callback - ) { + public void readKeypadLockoutAttribute(IntegerAttributeCallback callback) { readKeypadLockoutAttribute(chipClusterPtr, callback); } + public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value) { writeKeypadLockoutAttribute(chipClusterPtr, callback, value, null); } - public void writeKeypadLockoutAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeKeypadLockoutAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeKeypadLockoutAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeKeypadLockoutAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeKeypadLockoutAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readScheduleProgrammingVisibilityAttribute( - IntegerAttributeCallback callback - ) { + public void readScheduleProgrammingVisibilityAttribute(IntegerAttributeCallback callback) { readScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback); } - public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value) { + + public void writeScheduleProgrammingVisibilityAttribute( + DefaultClusterCallback callback, Integer value) { writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, null); } - public void writeScheduleProgrammingVisibilityAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { - writeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + public void writeScheduleProgrammingVisibilityAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + writeScheduleProgrammingVisibilityAttribute( + chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeScheduleProgrammingVisibilityAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeScheduleProgrammingVisibilityAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeScheduleProgrammingVisibilityAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { - readClusterRevisionAttribute(chipClusterPtr, callback); + 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 readTemperatureDisplayModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeTemperatureDisplayModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeTemperatureDisplayModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readKeypadLockoutAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeKeypadLockoutAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeKeypadLockoutAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readScheduleProgrammingVisibilityAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeScheduleProgrammingVisibilityAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeScheduleProgrammingVisibilityAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + } + + public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster { + public static final long CLUSTER_ID = 53L; + + public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) { + super(devicePtr, endpointId); + } + + @Override + public native long initWithDevice(long devicePtr, int endpointId); + + public void resetCounts(DefaultClusterCallback callback) { + resetCounts(chipClusterPtr, callback, null); + } + + public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { + + resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); + } + + private native void resetCounts( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface NeighborTableListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); + + public interface RouteTableListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void readTemperatureDisplayModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeTemperatureDisplayModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeTemperatureDisplayModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readKeypadLockoutAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeKeypadLockoutAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeKeypadLockoutAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readScheduleProgrammingVisibilityAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeScheduleProgrammingVisibilityAttribute(long chipClusterPtr, - IntegerAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - } + public interface SecurityPolicyAttributeCallback { + void onSuccess(List valueList); - public static class ThreadNetworkDiagnosticsCluster extends BaseChipCluster { - public static final long CLUSTER_ID = 53L; + void onError(Exception ex); - public ThreadNetworkDiagnosticsCluster(long devicePtr, int endpointId) { - super(devicePtr, endpointId); + default void onSubscriptionEstablished() {} } - @Override - public native long initWithDevice(long devicePtr, int endpointId); + public interface OperationalDatasetComponentsAttributeCallback { + void onSuccess( + List valueList); - public void resetCounts(DefaultClusterCallback callback - ) { - resetCounts(chipClusterPtr, callback, null); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - public void resetCounts(DefaultClusterCallback callback + public interface ActiveNetworkFaultsListAttributeCallback { + void onSuccess(List valueList); - , int timedInvokeTimeoutMs) { - resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); + void onError(Exception ex); + + default void onSubscriptionEstablished() {} } - private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); - public interface NeighborTableListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface RouteTableListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface SecurityPolicyAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface OperationalDatasetComponentsAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface ActiveNetworkFaultsListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readChannelAttribute( - IntegerAttributeCallback callback - ) { + public void readChannelAttribute(IntegerAttributeCallback callback) { readChannelAttribute(chipClusterPtr, callback); } + public void subscribeChannelAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeChannelAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRoutingRoleAttribute( - IntegerAttributeCallback callback - ) { + public void readRoutingRoleAttribute(IntegerAttributeCallback callback) { readRoutingRoleAttribute(chipClusterPtr, callback); } + public void subscribeRoutingRoleAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRoutingRoleAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNetworkNameAttribute( - CharStringAttributeCallback callback - ) { + public void readNetworkNameAttribute(CharStringAttributeCallback callback) { readNetworkNameAttribute(chipClusterPtr, callback); } + public void subscribeNetworkNameAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeNetworkNameAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPanIdAttribute( - IntegerAttributeCallback callback - ) { + public void readPanIdAttribute(IntegerAttributeCallback callback) { readPanIdAttribute(chipClusterPtr, callback); } + public void subscribePanIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readExtendedPanIdAttribute( - LongAttributeCallback callback - ) { + public void readExtendedPanIdAttribute(LongAttributeCallback callback) { readExtendedPanIdAttribute(chipClusterPtr, callback); } + public void subscribeExtendedPanIdAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeExtendedPanIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readMeshLocalPrefixAttribute( - OctetStringAttributeCallback callback - ) { + public void readMeshLocalPrefixAttribute(OctetStringAttributeCallback callback) { readMeshLocalPrefixAttribute(chipClusterPtr, callback); } + public void subscribeMeshLocalPrefixAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeMeshLocalPrefixAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute( - LongAttributeCallback callback - ) { + public void readOverrunCountAttribute(LongAttributeCallback callback) { readOverrunCountAttribute(chipClusterPtr, callback); } + public void subscribeOverrunCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readNeighborTableListAttribute( - NeighborTableListAttributeCallback callback - ) { + public void readNeighborTableListAttribute(NeighborTableListAttributeCallback callback) { readNeighborTableListAttribute(chipClusterPtr, callback); } + public void subscribeNeighborTableListAttribute( - NeighborTableListAttributeCallback callback - , - int minInterval, int maxInterval) { + NeighborTableListAttributeCallback callback, int minInterval, int maxInterval) { subscribeNeighborTableListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRouteTableListAttribute( - RouteTableListAttributeCallback callback - ) { + public void readRouteTableListAttribute(RouteTableListAttributeCallback callback) { readRouteTableListAttribute(chipClusterPtr, callback); } + public void subscribeRouteTableListAttribute( - RouteTableListAttributeCallback callback - , - int minInterval, int maxInterval) { + RouteTableListAttributeCallback callback, int minInterval, int maxInterval) { subscribeRouteTableListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartitionIdAttribute( - LongAttributeCallback callback - ) { + public void readPartitionIdAttribute(LongAttributeCallback callback) { readPartitionIdAttribute(chipClusterPtr, callback); } + public void subscribePartitionIdAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePartitionIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWeightingAttribute( - IntegerAttributeCallback callback - ) { + public void readWeightingAttribute(IntegerAttributeCallback callback) { readWeightingAttribute(chipClusterPtr, callback); } + public void subscribeWeightingAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWeightingAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDataVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readDataVersionAttribute(IntegerAttributeCallback callback) { readDataVersionAttribute(chipClusterPtr, callback); } + public void subscribeDataVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readStableDataVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readStableDataVersionAttribute(IntegerAttributeCallback callback) { readStableDataVersionAttribute(chipClusterPtr, callback); } + public void subscribeStableDataVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeStableDataVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLeaderRouterIdAttribute( - IntegerAttributeCallback callback - ) { + public void readLeaderRouterIdAttribute(IntegerAttributeCallback callback) { readLeaderRouterIdAttribute(chipClusterPtr, callback); } + public void subscribeLeaderRouterIdAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLeaderRouterIdAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDetachedRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readDetachedRoleCountAttribute(IntegerAttributeCallback callback) { readDetachedRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeDetachedRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeDetachedRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readChildRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readChildRoleCountAttribute(IntegerAttributeCallback callback) { readChildRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeChildRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeChildRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRouterRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readRouterRoleCountAttribute(IntegerAttributeCallback callback) { readRouterRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeRouterRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRouterRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readLeaderRoleCountAttribute( - IntegerAttributeCallback callback - ) { + public void readLeaderRoleCountAttribute(IntegerAttributeCallback callback) { readLeaderRoleCountAttribute(chipClusterPtr, callback); } + public void subscribeLeaderRoleCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeLeaderRoleCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttachAttemptCountAttribute( - IntegerAttributeCallback callback - ) { + public void readAttachAttemptCountAttribute(IntegerAttributeCallback callback) { readAttachAttemptCountAttribute(chipClusterPtr, callback); } + public void subscribeAttachAttemptCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPartitionIdChangeCountAttribute( - IntegerAttributeCallback callback - ) { + public void readPartitionIdChangeCountAttribute(IntegerAttributeCallback callback) { readPartitionIdChangeCountAttribute(chipClusterPtr, callback); } + public void subscribePartitionIdChangeCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribePartitionIdChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBetterPartitionAttachAttemptCountAttribute( - IntegerAttributeCallback callback - ) { + public void readBetterPartitionAttachAttemptCountAttribute(IntegerAttributeCallback callback) { readBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback); } + public void subscribeBetterPartitionAttachAttemptCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeBetterPartitionAttachAttemptCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeBetterPartitionAttachAttemptCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readParentChangeCountAttribute( - IntegerAttributeCallback callback - ) { + public void readParentChangeCountAttribute(IntegerAttributeCallback callback) { readParentChangeCountAttribute(chipClusterPtr, callback); } + public void subscribeParentChangeCountAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeParentChangeCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxTotalCountAttribute( - LongAttributeCallback callback - ) { + public void readTxTotalCountAttribute(LongAttributeCallback callback) { readTxTotalCountAttribute(chipClusterPtr, callback); } + public void subscribeTxTotalCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxUnicastCountAttribute( - LongAttributeCallback callback - ) { + public void readTxUnicastCountAttribute(LongAttributeCallback callback) { readTxUnicastCountAttribute(chipClusterPtr, callback); } + public void subscribeTxUnicastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBroadcastCountAttribute( - LongAttributeCallback callback - ) { + public void readTxBroadcastCountAttribute(LongAttributeCallback callback) { readTxBroadcastCountAttribute(chipClusterPtr, callback); } + public void subscribeTxBroadcastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxAckRequestedCountAttribute( - LongAttributeCallback callback - ) { + public void readTxAckRequestedCountAttribute(LongAttributeCallback callback) { readTxAckRequestedCountAttribute(chipClusterPtr, callback); } + public void subscribeTxAckRequestedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxAckedCountAttribute( - LongAttributeCallback callback - ) { + public void readTxAckedCountAttribute(LongAttributeCallback callback) { readTxAckedCountAttribute(chipClusterPtr, callback); } + public void subscribeTxAckedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxAckedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxNoAckRequestedCountAttribute( - LongAttributeCallback callback - ) { + public void readTxNoAckRequestedCountAttribute(LongAttributeCallback callback) { readTxNoAckRequestedCountAttribute(chipClusterPtr, callback); } + public void subscribeTxNoAckRequestedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxNoAckRequestedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDataCountAttribute( - LongAttributeCallback callback - ) { + public void readTxDataCountAttribute(LongAttributeCallback callback) { readTxDataCountAttribute(chipClusterPtr, callback); } + public void subscribeTxDataCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDataPollCountAttribute( - LongAttributeCallback callback - ) { + public void readTxDataPollCountAttribute(LongAttributeCallback callback) { readTxDataPollCountAttribute(chipClusterPtr, callback); } + public void subscribeTxDataPollCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBeaconCountAttribute( - LongAttributeCallback callback - ) { + public void readTxBeaconCountAttribute(LongAttributeCallback callback) { readTxBeaconCountAttribute(chipClusterPtr, callback); } + public void subscribeTxBeaconCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxBeaconRequestCountAttribute( - LongAttributeCallback callback - ) { + public void readTxBeaconRequestCountAttribute(LongAttributeCallback callback) { readTxBeaconRequestCountAttribute(chipClusterPtr, callback); } + public void subscribeTxBeaconRequestCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxOtherCountAttribute( - LongAttributeCallback callback - ) { + public void readTxOtherCountAttribute(LongAttributeCallback callback) { readTxOtherCountAttribute(chipClusterPtr, callback); } + public void subscribeTxOtherCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxRetryCountAttribute( - LongAttributeCallback callback - ) { + public void readTxRetryCountAttribute(LongAttributeCallback callback) { readTxRetryCountAttribute(chipClusterPtr, callback); } + public void subscribeTxRetryCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxRetryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxDirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback - ) { + public void readTxDirectMaxRetryExpiryCountAttribute(LongAttributeCallback callback) { readTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); } + public void subscribeTxDirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeTxDirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeTxDirectMaxRetryExpiryCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxIndirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback - ) { + public void readTxIndirectMaxRetryExpiryCountAttribute(LongAttributeCallback callback) { readTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback); } + public void subscribeTxIndirectMaxRetryExpiryCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeTxIndirectMaxRetryExpiryCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeTxIndirectMaxRetryExpiryCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrCcaCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrCcaCountAttribute(LongAttributeCallback callback) { readTxErrCcaCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrCcaCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrCcaCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrAbortCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrAbortCountAttribute(LongAttributeCallback callback) { readTxErrAbortCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrAbortCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrAbortCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readTxErrBusyChannelCountAttribute( - LongAttributeCallback callback - ) { + public void readTxErrBusyChannelCountAttribute(LongAttributeCallback callback) { readTxErrBusyChannelCountAttribute(chipClusterPtr, callback); } + public void subscribeTxErrBusyChannelCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeTxErrBusyChannelCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxTotalCountAttribute( - LongAttributeCallback callback - ) { + public void readRxTotalCountAttribute(LongAttributeCallback callback) { readRxTotalCountAttribute(chipClusterPtr, callback); } + public void subscribeRxTotalCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxTotalCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxUnicastCountAttribute( - LongAttributeCallback callback - ) { + public void readRxUnicastCountAttribute(LongAttributeCallback callback) { readRxUnicastCountAttribute(chipClusterPtr, callback); } + public void subscribeRxUnicastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxUnicastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBroadcastCountAttribute( - LongAttributeCallback callback - ) { + public void readRxBroadcastCountAttribute(LongAttributeCallback callback) { readRxBroadcastCountAttribute(chipClusterPtr, callback); } + public void subscribeRxBroadcastCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxBroadcastCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDataCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDataCountAttribute(LongAttributeCallback callback) { readRxDataCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDataCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDataCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDataPollCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDataPollCountAttribute(LongAttributeCallback callback) { readRxDataPollCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDataPollCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDataPollCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBeaconCountAttribute( - LongAttributeCallback callback - ) { + public void readRxBeaconCountAttribute(LongAttributeCallback callback) { readRxBeaconCountAttribute(chipClusterPtr, callback); } + public void subscribeRxBeaconCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxBeaconCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxBeaconRequestCountAttribute( - LongAttributeCallback callback - ) { + public void readRxBeaconRequestCountAttribute(LongAttributeCallback callback) { readRxBeaconRequestCountAttribute(chipClusterPtr, callback); } + public void subscribeRxBeaconRequestCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxBeaconRequestCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxOtherCountAttribute( - LongAttributeCallback callback - ) { + public void readRxOtherCountAttribute(LongAttributeCallback callback) { readRxOtherCountAttribute(chipClusterPtr, callback); } + public void subscribeRxOtherCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxAddressFilteredCountAttribute( - LongAttributeCallback callback - ) { + public void readRxAddressFilteredCountAttribute(LongAttributeCallback callback) { readRxAddressFilteredCountAttribute(chipClusterPtr, callback); } + public void subscribeRxAddressFilteredCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxAddressFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDestAddrFilteredCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDestAddrFilteredCountAttribute(LongAttributeCallback callback) { readRxDestAddrFilteredCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDestAddrFilteredCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDestAddrFilteredCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxDuplicatedCountAttribute( - LongAttributeCallback callback - ) { + public void readRxDuplicatedCountAttribute(LongAttributeCallback callback) { readRxDuplicatedCountAttribute(chipClusterPtr, callback); } + public void subscribeRxDuplicatedCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxDuplicatedCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrNoFrameCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrNoFrameCountAttribute(LongAttributeCallback callback) { readRxErrNoFrameCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrNoFrameCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrNoFrameCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrUnknownNeighborCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrUnknownNeighborCountAttribute(LongAttributeCallback callback) { readRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrUnknownNeighborCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeRxErrUnknownNeighborCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeRxErrUnknownNeighborCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrInvalidSrcAddrCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrInvalidSrcAddrCountAttribute(LongAttributeCallback callback) { readRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrInvalidSrcAddrCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeRxErrInvalidSrcAddrCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); + LongAttributeCallback callback, int minInterval, int maxInterval) { + subscribeRxErrInvalidSrcAddrCountAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrSecCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrSecCountAttribute(LongAttributeCallback callback) { readRxErrSecCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrSecCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrSecCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrFcsCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrFcsCountAttribute(LongAttributeCallback callback) { readRxErrFcsCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrFcsCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrFcsCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRxErrOtherCountAttribute( - LongAttributeCallback callback - ) { + public void readRxErrOtherCountAttribute(LongAttributeCallback callback) { readRxErrOtherCountAttribute(chipClusterPtr, callback); } + public void subscribeRxErrOtherCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeRxErrOtherCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveTimestampAttribute( - LongAttributeCallback callback - ) { + public void readActiveTimestampAttribute(LongAttributeCallback callback) { readActiveTimestampAttribute(chipClusterPtr, callback); } + public void subscribeActiveTimestampAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPendingTimestampAttribute( - LongAttributeCallback callback - ) { + public void readPendingTimestampAttribute(LongAttributeCallback callback) { readPendingTimestampAttribute(chipClusterPtr, callback); } + public void subscribePendingTimestampAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePendingTimestampAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readDelayAttribute( - LongAttributeCallback callback - ) { + public void readDelayAttribute(LongAttributeCallback callback) { readDelayAttribute(chipClusterPtr, callback); } + public void subscribeDelayAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeDelayAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSecurityPolicyAttribute( - SecurityPolicyAttributeCallback callback - ) { - readSecurityPolicyAttribute(chipClusterPtr, callback); - } - public void subscribeSecurityPolicyAttribute( - SecurityPolicyAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeSecurityPolicyAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + public void readSecurityPolicyAttribute(SecurityPolicyAttributeCallback callback) { + readSecurityPolicyAttribute(chipClusterPtr, callback); + } + + public void subscribeSecurityPolicyAttribute( + SecurityPolicyAttributeCallback callback, int minInterval, int maxInterval) { + subscribeSecurityPolicyAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readChannelMaskAttribute(OctetStringAttributeCallback callback) { + readChannelMaskAttribute(chipClusterPtr, callback); + } + + public void subscribeChannelMaskAttribute( + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { + subscribeChannelMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readOperationalDatasetComponentsAttribute( + OperationalDatasetComponentsAttributeCallback callback) { + readOperationalDatasetComponentsAttribute(chipClusterPtr, callback); + } + + public void subscribeOperationalDatasetComponentsAttribute( + OperationalDatasetComponentsAttributeCallback callback, int minInterval, int maxInterval) { + subscribeOperationalDatasetComponentsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); + } + + public void readActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback) { + readActiveNetworkFaultsListAttribute(chipClusterPtr, callback); + } + + public void subscribeActiveNetworkFaultsListAttribute( + ActiveNetworkFaultsListAttributeCallback callback, int minInterval, int maxInterval) { + subscribeActiveNetworkFaultsListAttribute(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 readChannelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeChannelAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRoutingRoleAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRoutingRoleAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNetworkNameAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeNetworkNameAttribute( + long chipClusterPtr, + CharStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPanIdAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePanIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readExtendedPanIdAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeExtendedPanIdAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readMeshLocalPrefixAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeMeshLocalPrefixAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readNeighborTableListAttribute( + long chipClusterPtr, NeighborTableListAttributeCallback callback); + + private native void subscribeNeighborTableListAttribute( + long chipClusterPtr, + NeighborTableListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readRouteTableListAttribute( + long chipClusterPtr, RouteTableListAttributeCallback callback); + + private native void subscribeRouteTableListAttribute( + long chipClusterPtr, + RouteTableListAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readPartitionIdAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePartitionIdAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWeightingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeWeightingAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readStableDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeStableDataVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLeaderRouterIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLeaderRouterIdAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDetachedRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeDetachedRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readChildRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeChildRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRouterRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRouterRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readLeaderRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeLeaderRoleCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPartitionIdChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribePartitionIdChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBetterPartitionAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeBetterPartitionAttachAttemptCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readParentChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeParentChangeCountAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxAckedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxAckedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxNoAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxNoAckRequestedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxRetryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxRetryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxDirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxDirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxIndirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxIndirectMaxRetryExpiryCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrCcaCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrCcaCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrAbortCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrAbortCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTxErrBusyChannelCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeTxErrBusyChannelCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxTotalCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxUnicastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxBroadcastCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDataCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDataPollCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxBeaconCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxBeaconRequestCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxAddressFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxAddressFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDestAddrFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDestAddrFilteredCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxDuplicatedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxDuplicatedCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrNoFrameCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrNoFrameCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrUnknownNeighborCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrUnknownNeighborCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrInvalidSrcAddrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrInvalidSrcAddrCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrSecCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrSecCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrFcsCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrFcsCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRxErrOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeRxErrOtherCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeActiveTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPendingTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePendingTimestampAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readDelayAttribute(long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeDelayAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSecurityPolicyAttribute( + long chipClusterPtr, SecurityPolicyAttributeCallback callback); + + private native void subscribeSecurityPolicyAttribute( + long chipClusterPtr, + SecurityPolicyAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readChannelMaskAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeChannelMaskAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOperationalDatasetComponentsAttribute( + long chipClusterPtr, OperationalDatasetComponentsAttributeCallback callback); - public void readChannelMaskAttribute( - OctetStringAttributeCallback callback - ) { - readChannelMaskAttribute(chipClusterPtr, callback); - } - public void subscribeChannelMaskAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeChannelMaskAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeOperationalDatasetComponentsAttribute( + long chipClusterPtr, + OperationalDatasetComponentsAttributeCallback callback, + int minInterval, + int maxInterval); - public void readOperationalDatasetComponentsAttribute( - OperationalDatasetComponentsAttributeCallback callback - ) { - readOperationalDatasetComponentsAttribute(chipClusterPtr, callback); - } - public void subscribeOperationalDatasetComponentsAttribute( - OperationalDatasetComponentsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeOperationalDatasetComponentsAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readActiveNetworkFaultsListAttribute( + long chipClusterPtr, ActiveNetworkFaultsListAttributeCallback callback); - public void readActiveNetworkFaultsListAttribute( - ActiveNetworkFaultsListAttributeCallback callback - ) { - readActiveNetworkFaultsListAttribute(chipClusterPtr, callback); - } - public void subscribeActiveNetworkFaultsListAttribute( - ActiveNetworkFaultsListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeActiveNetworkFaultsListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeActiveNetworkFaultsListAttribute( + long chipClusterPtr, + ActiveNetworkFaultsListAttributeCallback callback, + int minInterval, + int maxInterval); - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { - readAttributeListAttribute(chipClusterPtr, callback); - } - public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void readAttributeListAttribute( + long chipClusterPtr, AttributeListAttributeCallback callback); - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { - readFeatureMapAttribute(chipClusterPtr, callback); - } - public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); - } + private native void subscribeAttributeListAttribute( + long chipClusterPtr, + AttributeListAttributeCallback callback, + int minInterval, + int 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 readFeatureMapAttribute( + long chipClusterPtr, LongAttributeCallback callback); - private native void readChannelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeChannelAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRoutingRoleAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRoutingRoleAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNetworkNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeNetworkNameAttribute(long chipClusterPtr, - CharStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPanIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePanIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readExtendedPanIdAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeExtendedPanIdAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readMeshLocalPrefixAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeMeshLocalPrefixAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readNeighborTableListAttribute(long chipClusterPtr, - NeighborTableListAttributeCallback callback - ); - private native void subscribeNeighborTableListAttribute(long chipClusterPtr, - NeighborTableListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readRouteTableListAttribute(long chipClusterPtr, - RouteTableListAttributeCallback callback - ); - private native void subscribeRouteTableListAttribute(long chipClusterPtr, - RouteTableListAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readPartitionIdAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePartitionIdAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWeightingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeWeightingAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readStableDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeStableDataVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLeaderRouterIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLeaderRouterIdAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDetachedRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeDetachedRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readChildRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeChildRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRouterRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRouterRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readLeaderRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeLeaderRoleCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPartitionIdChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribePartitionIdChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeBetterPartitionAttachAttemptCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readParentChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeParentChangeCountAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxAckedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxAckedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxNoAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxNoAckRequestedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxRetryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxRetryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxDirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxIndirectMaxRetryExpiryCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrCcaCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrCcaCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrAbortCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrAbortCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTxErrBusyChannelCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeTxErrBusyChannelCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxTotalCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxUnicastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxBroadcastCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDataCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDataPollCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxBeaconCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxBeaconRequestCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxAddressFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxAddressFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDestAddrFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDestAddrFilteredCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxDuplicatedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxDuplicatedCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrNoFrameCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrNoFrameCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrUnknownNeighborCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrUnknownNeighborCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrInvalidSrcAddrCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrSecCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrSecCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrFcsCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrFcsCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRxErrOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeRxErrOtherCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeActiveTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPendingTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePendingTimestampAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readDelayAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeDelayAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSecurityPolicyAttribute(long chipClusterPtr, - SecurityPolicyAttributeCallback callback - ); - private native void subscribeSecurityPolicyAttribute(long chipClusterPtr, - SecurityPolicyAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readChannelMaskAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeChannelMaskAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOperationalDatasetComponentsAttribute(long chipClusterPtr, - OperationalDatasetComponentsAttributeCallback callback - ); - private native void subscribeOperationalDatasetComponentsAttribute(long chipClusterPtr, - OperationalDatasetComponentsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readActiveNetworkFaultsListAttribute(long chipClusterPtr, - ActiveNetworkFaultsListAttributeCallback callback - ); - private native void subscribeActiveNetworkFaultsListAttribute(long chipClusterPtr, - ActiveNetworkFaultsListAttributeCallback 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); + 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 TimeFormatLocalizationCluster extends BaseChipCluster { @@ -16223,105 +17276,107 @@ public TimeFormatLocalizationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface SupportedCalendarTypesAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface SupportedCalendarTypesAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); - public void readHourFormatAttribute( - IntegerAttributeCallback callback - ) { + default void onSubscriptionEstablished() {} + } + + public void readHourFormatAttribute(IntegerAttributeCallback callback) { readHourFormatAttribute(chipClusterPtr, callback); } + public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value) { writeHourFormatAttribute(chipClusterPtr, callback, value, null); } - public void writeHourFormatAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeHourFormatAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeHourFormatAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeHourFormatAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeHourFormatAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readActiveCalendarTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readActiveCalendarTypeAttribute(IntegerAttributeCallback callback) { readActiveCalendarTypeAttribute(chipClusterPtr, callback); } + public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value) { writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, null); } - public void writeActiveCalendarTypeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeActiveCalendarTypeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeActiveCalendarTypeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeActiveCalendarTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeActiveCalendarTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readSupportedCalendarTypesAttribute( - SupportedCalendarTypesAttributeCallback callback - ) { + SupportedCalendarTypesAttributeCallback callback) { readSupportedCalendarTypesAttribute(chipClusterPtr, callback); } + public void subscribeSupportedCalendarTypesAttribute( - SupportedCalendarTypesAttributeCallback callback - , - int minInterval, int maxInterval) { + SupportedCalendarTypesAttributeCallback callback, int minInterval, int maxInterval) { subscribeSupportedCalendarTypesAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readHourFormatAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeHourFormatAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeHourFormatAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readActiveCalendarTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeActiveCalendarTypeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeActiveCalendarTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSupportedCalendarTypesAttribute(long chipClusterPtr, - SupportedCalendarTypesAttributeCallback callback - ); - private native void subscribeSupportedCalendarTypesAttribute(long chipClusterPtr, - SupportedCalendarTypesAttributeCallback 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); + private native void readHourFormatAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeHourFormatAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeHourFormatAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readActiveCalendarTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeActiveCalendarTypeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeActiveCalendarTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSupportedCalendarTypesAttribute( + long chipClusterPtr, SupportedCalendarTypesAttributeCallback callback); + + private native void subscribeSupportedCalendarTypesAttribute( + long chipClusterPtr, + SupportedCalendarTypesAttributeCallback 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 UnitLocalizationCluster extends BaseChipCluster { @@ -16334,72 +17389,65 @@ public UnitLocalizationCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - - public void readTemperatureUnitAttribute( - IntegerAttributeCallback callback - ) { + public void readTemperatureUnitAttribute(IntegerAttributeCallback callback) { readTemperatureUnitAttribute(chipClusterPtr, callback); } + public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value) { writeTemperatureUnitAttribute(chipClusterPtr, callback, value, null); } - public void writeTemperatureUnitAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeTemperatureUnitAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeTemperatureUnitAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeTemperatureUnitAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeTemperatureUnitAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTemperatureUnitAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeTemperatureUnitAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeTemperatureUnitAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readTemperatureUnitAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeTemperatureUnitAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeTemperatureUnitAttribute( + long chipClusterPtr, IntegerAttributeCallback 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 UserLabelCluster extends BaseChipCluster { @@ -16412,58 +17460,61 @@ public UserLabelCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface LabelListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface LabelListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readLabelListAttribute( - LabelListAttributeCallback callback - ) { + public void readLabelListAttribute(LabelListAttributeCallback callback) { readLabelListAttribute(chipClusterPtr, callback); } - public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value) { + + public void writeLabelListAttribute( + DefaultClusterCallback callback, ArrayList value) { writeLabelListAttribute(chipClusterPtr, callback, value, null); } - public void writeLabelListAttribute(DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + public void writeLabelListAttribute( + DefaultClusterCallback callback, + ArrayList value, + int timedWriteTimeoutMs) { writeLabelListAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeLabelListAttribute( - LabelListAttributeCallback callback - , - int minInterval, int maxInterval) { + LabelListAttributeCallback callback, int minInterval, int maxInterval) { subscribeLabelListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback callback - ); + private native void readLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback callback); + + private native void writeLabelListAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); - private native void writeLabelListAttribute(long chipClusterPtr, DefaultClusterCallback callback, ArrayList value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeLabelListAttribute(long chipClusterPtr, - LabelListAttributeCallback callback - , int minInterval, int maxInterval); + private native void subscribeLabelListAttribute( + long chipClusterPtr, LabelListAttributeCallback 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); + private native void readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class WakeOnLanCluster extends BaseChipCluster { @@ -16476,68 +17527,64 @@ public WakeOnLanCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readWakeOnLanMacAddressAttribute( - CharStringAttributeCallback callback - ) { + public void readWakeOnLanMacAddressAttribute(CharStringAttributeCallback callback) { readWakeOnLanMacAddressAttribute(chipClusterPtr, callback); } + public void subscribeWakeOnLanMacAddressAttribute( - CharStringAttributeCallback callback -, - int minInterval, int maxInterval) { + CharStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeWakeOnLanMacAddressAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readWakeOnLanMacAddressAttribute(long chipClusterPtr, - CharStringAttributeCallback callback - ); - private native void subscribeWakeOnLanMacAddressAttribute(long chipClusterPtr, - CharStringAttributeCallback 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 readClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeClusterRevisionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); + private native void readWakeOnLanMacAddressAttribute( + long chipClusterPtr, CharStringAttributeCallback callback); + + private native void subscribeWakeOnLanMacAddressAttribute( + long chipClusterPtr, + CharStringAttributeCallback 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 readClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeClusterRevisionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); } public static class WiFiNetworkDiagnosticsCluster extends BaseChipCluster { @@ -16550,329 +17597,272 @@ public WiFiNetworkDiagnosticsCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void resetCounts(DefaultClusterCallback callback - ) { + public void resetCounts(DefaultClusterCallback callback) { resetCounts(chipClusterPtr, callback, null); } - public void resetCounts(DefaultClusterCallback callback + public void resetCounts(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { resetCounts(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void resetCounts(long chipClusterPtr, DefaultClusterCallback Callback - , @Nullable Integer timedInvokeTimeoutMs); + private native void resetCounts( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } - public void readBssidAttribute( - OctetStringAttributeCallback callback - ) { + public void readBssidAttribute(OctetStringAttributeCallback callback) { readBssidAttribute(chipClusterPtr, callback); } + public void subscribeBssidAttribute( - OctetStringAttributeCallback callback -, - int minInterval, int maxInterval) { + OctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeBssidAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSecurityTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readSecurityTypeAttribute(IntegerAttributeCallback callback) { readSecurityTypeAttribute(chipClusterPtr, callback); } + public void subscribeSecurityTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSecurityTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readWiFiVersionAttribute( - IntegerAttributeCallback callback - ) { + public void readWiFiVersionAttribute(IntegerAttributeCallback callback) { readWiFiVersionAttribute(chipClusterPtr, callback); } + public void subscribeWiFiVersionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeWiFiVersionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readChannelNumberAttribute( - IntegerAttributeCallback callback - ) { + public void readChannelNumberAttribute(IntegerAttributeCallback callback) { readChannelNumberAttribute(chipClusterPtr, callback); } + public void subscribeChannelNumberAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeChannelNumberAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readRssiAttribute( - IntegerAttributeCallback callback - ) { + public void readRssiAttribute(IntegerAttributeCallback callback) { readRssiAttribute(chipClusterPtr, callback); } + public void subscribeRssiAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeRssiAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBeaconLostCountAttribute( - LongAttributeCallback callback - ) { + public void readBeaconLostCountAttribute(LongAttributeCallback callback) { readBeaconLostCountAttribute(chipClusterPtr, callback); } + public void subscribeBeaconLostCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBeaconLostCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readBeaconRxCountAttribute( - LongAttributeCallback callback - ) { + public void readBeaconRxCountAttribute(LongAttributeCallback callback) { readBeaconRxCountAttribute(chipClusterPtr, callback); } + public void subscribeBeaconRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeBeaconRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketMulticastRxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketMulticastRxCountAttribute(LongAttributeCallback callback) { readPacketMulticastRxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketMulticastRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketMulticastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketMulticastTxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketMulticastTxCountAttribute(LongAttributeCallback callback) { readPacketMulticastTxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketMulticastTxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketMulticastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketUnicastRxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketUnicastRxCountAttribute(LongAttributeCallback callback) { readPacketUnicastRxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketUnicastRxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketUnicastRxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readPacketUnicastTxCountAttribute( - LongAttributeCallback callback - ) { + public void readPacketUnicastTxCountAttribute(LongAttributeCallback callback) { readPacketUnicastTxCountAttribute(chipClusterPtr, callback); } + public void subscribePacketUnicastTxCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribePacketUnicastTxCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentMaxRateAttribute( - LongAttributeCallback callback - ) { + public void readCurrentMaxRateAttribute(LongAttributeCallback callback) { readCurrentMaxRateAttribute(chipClusterPtr, callback); } + public void subscribeCurrentMaxRateAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentMaxRateAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readOverrunCountAttribute( - LongAttributeCallback callback - ) { + public void readOverrunCountAttribute(LongAttributeCallback callback) { readOverrunCountAttribute(chipClusterPtr, callback); } + public void subscribeOverrunCountAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeOverrunCountAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readBssidAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback - ); - private native void subscribeBssidAttribute(long chipClusterPtr, - OctetStringAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSecurityTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSecurityTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readWiFiVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeWiFiVersionAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readChannelNumberAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeChannelNumberAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readRssiAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeRssiAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBeaconLostCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBeaconLostCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readBeaconRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeBeaconRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketMulticastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketMulticastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketMulticastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketMulticastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketUnicastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketUnicastRxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readPacketUnicastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribePacketUnicastTxCountAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentMaxRateAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeCurrentMaxRateAttribute(long chipClusterPtr, - LongAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback callback - ); - private native void subscribeOverrunCountAttribute(long chipClusterPtr, - LongAttributeCallback 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); + private native void readBssidAttribute( + long chipClusterPtr, OctetStringAttributeCallback callback); + + private native void subscribeBssidAttribute( + long chipClusterPtr, + OctetStringAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readSecurityTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSecurityTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readWiFiVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeWiFiVersionAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readChannelNumberAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeChannelNumberAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readRssiAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeRssiAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBeaconLostCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBeaconLostCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readBeaconRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeBeaconRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketMulticastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketMulticastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketMulticastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketMulticastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketUnicastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketUnicastRxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readPacketUnicastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribePacketUnicastTxCountAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentMaxRateAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeCurrentMaxRateAttribute( + long chipClusterPtr, LongAttributeCallback callback, int minInterval, int maxInterval); + + private native void readOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback callback); + + private native void subscribeOverrunCountAttribute( + long chipClusterPtr, LongAttributeCallback 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 WindowCoveringCluster extends BaseChipCluster { @@ -16885,556 +17875,581 @@ public WindowCoveringCluster(long devicePtr, int endpointId) { @Override public native long initWithDevice(long devicePtr, int endpointId); - public void downOrClose(DefaultClusterCallback callback - ) { + public void downOrClose(DefaultClusterCallback callback) { downOrClose(chipClusterPtr, callback, null); } - public void downOrClose(DefaultClusterCallback callback + public void downOrClose(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { downOrClose(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void goToLiftPercentage(DefaultClusterCallback callback - , Integer liftPercentageValue, Integer liftPercent100thsValue) { - goToLiftPercentage(chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, null); + public void goToLiftPercentage( + DefaultClusterCallback callback, + Integer liftPercentageValue, + Integer liftPercent100thsValue) { + goToLiftPercentage( + chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, null); } - public void goToLiftPercentage(DefaultClusterCallback callback - , Integer liftPercentageValue, Integer liftPercent100thsValue - , int timedInvokeTimeoutMs) { - goToLiftPercentage(chipClusterPtr, callback, liftPercentageValue, liftPercent100thsValue, timedInvokeTimeoutMs); + public void goToLiftPercentage( + DefaultClusterCallback callback, + Integer liftPercentageValue, + Integer liftPercent100thsValue, + int timedInvokeTimeoutMs) { + goToLiftPercentage( + chipClusterPtr, + callback, + liftPercentageValue, + liftPercent100thsValue, + timedInvokeTimeoutMs); } - public void goToLiftValue(DefaultClusterCallback callback - , Integer liftValue) { + public void goToLiftValue(DefaultClusterCallback callback, Integer liftValue) { goToLiftValue(chipClusterPtr, callback, liftValue, null); } - public void goToLiftValue(DefaultClusterCallback callback - , Integer liftValue - , int timedInvokeTimeoutMs) { + public void goToLiftValue( + DefaultClusterCallback callback, Integer liftValue, int timedInvokeTimeoutMs) { goToLiftValue(chipClusterPtr, callback, liftValue, timedInvokeTimeoutMs); } - public void goToTiltPercentage(DefaultClusterCallback callback - , Integer tiltPercentageValue, Integer tiltPercent100thsValue) { - goToTiltPercentage(chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, null); + public void goToTiltPercentage( + DefaultClusterCallback callback, + Integer tiltPercentageValue, + Integer tiltPercent100thsValue) { + goToTiltPercentage( + chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, null); } - public void goToTiltPercentage(DefaultClusterCallback callback - , Integer tiltPercentageValue, Integer tiltPercent100thsValue - , int timedInvokeTimeoutMs) { - goToTiltPercentage(chipClusterPtr, callback, tiltPercentageValue, tiltPercent100thsValue, timedInvokeTimeoutMs); + public void goToTiltPercentage( + DefaultClusterCallback callback, + Integer tiltPercentageValue, + Integer tiltPercent100thsValue, + int timedInvokeTimeoutMs) { + goToTiltPercentage( + chipClusterPtr, + callback, + tiltPercentageValue, + tiltPercent100thsValue, + timedInvokeTimeoutMs); } - public void goToTiltValue(DefaultClusterCallback callback - , Integer tiltValue) { + public void goToTiltValue(DefaultClusterCallback callback, Integer tiltValue) { goToTiltValue(chipClusterPtr, callback, tiltValue, null); } - public void goToTiltValue(DefaultClusterCallback callback - , Integer tiltValue - , int timedInvokeTimeoutMs) { + public void goToTiltValue( + DefaultClusterCallback callback, Integer tiltValue, int timedInvokeTimeoutMs) { goToTiltValue(chipClusterPtr, callback, tiltValue, timedInvokeTimeoutMs); } - public void stopMotion(DefaultClusterCallback callback - ) { + public void stopMotion(DefaultClusterCallback callback) { stopMotion(chipClusterPtr, callback, null); } - public void stopMotion(DefaultClusterCallback callback + public void stopMotion(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { stopMotion(chipClusterPtr, callback, timedInvokeTimeoutMs); } - public void upOrOpen(DefaultClusterCallback callback - ) { + public void upOrOpen(DefaultClusterCallback callback) { upOrOpen(chipClusterPtr, callback, null); } - public void upOrOpen(DefaultClusterCallback callback + public void upOrOpen(DefaultClusterCallback callback, int timedInvokeTimeoutMs) { - , int timedInvokeTimeoutMs) { upOrOpen(chipClusterPtr, callback, timedInvokeTimeoutMs); } - private native void downOrClose(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToLiftPercentage(long chipClusterPtr, DefaultClusterCallback Callback - , Integer liftPercentageValue, Integer liftPercent100thsValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToLiftValue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer liftValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToTiltPercentage(long chipClusterPtr, DefaultClusterCallback Callback - , Integer tiltPercentageValue, Integer tiltPercent100thsValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void goToTiltValue(long chipClusterPtr, DefaultClusterCallback Callback - , Integer tiltValue - , @Nullable Integer timedInvokeTimeoutMs); - private native void stopMotion(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - private native void upOrOpen(long chipClusterPtr, DefaultClusterCallback Callback - - , @Nullable Integer timedInvokeTimeoutMs); - - public interface CurrentPositionLiftAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionTiltAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionLiftPercentageAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionTiltPercentageAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface TargetPositionLiftPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface TargetPositionTiltPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionLiftPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface CurrentPositionTiltPercent100thsAttributeCallback { - void onSuccess(@Nullable Integer value); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public interface AttributeListAttributeCallback { - void onSuccess( List valueList); - void onError(Exception ex); - default void onSubscriptionEstablished() {} - } - public void readTypeAttribute( - IntegerAttributeCallback callback - ) { + private native void downOrClose( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToLiftPercentage( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer liftPercentageValue, + Integer liftPercent100thsValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToLiftValue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer liftValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToTiltPercentage( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer tiltPercentageValue, + Integer tiltPercent100thsValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void goToTiltValue( + long chipClusterPtr, + DefaultClusterCallback Callback, + Integer tiltValue, + @Nullable Integer timedInvokeTimeoutMs); + + private native void stopMotion( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + private native void upOrOpen( + long chipClusterPtr, + DefaultClusterCallback Callback, + @Nullable Integer timedInvokeTimeoutMs); + + public interface CurrentPositionLiftAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionTiltAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionLiftPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionTiltPercentageAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface TargetPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface TargetPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionLiftPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface CurrentPositionTiltPercent100thsAttributeCallback { + void onSuccess(@Nullable Integer value); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public interface AttributeListAttributeCallback { + void onSuccess(List valueList); + + void onError(Exception ex); + + default void onSubscriptionEstablished() {} + } + + public void readTypeAttribute(IntegerAttributeCallback callback) { readTypeAttribute(chipClusterPtr, callback); } + public void subscribeTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionLiftAttribute( - CurrentPositionLiftAttributeCallback callback - ) { + public void readCurrentPositionLiftAttribute(CurrentPositionLiftAttributeCallback callback) { readCurrentPositionLiftAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionLiftAttribute( - CurrentPositionLiftAttributeCallback callback - , - int minInterval, int maxInterval) { + CurrentPositionLiftAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentPositionLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readCurrentPositionTiltAttribute( - CurrentPositionTiltAttributeCallback callback - ) { + public void readCurrentPositionTiltAttribute(CurrentPositionTiltAttributeCallback callback) { readCurrentPositionTiltAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionTiltAttribute( - CurrentPositionTiltAttributeCallback callback - , - int minInterval, int maxInterval) { + CurrentPositionTiltAttributeCallback callback, int minInterval, int maxInterval) { subscribeCurrentPositionTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readConfigStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readConfigStatusAttribute(IntegerAttributeCallback callback) { readConfigStatusAttribute(chipClusterPtr, callback); } + public void subscribeConfigStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeConfigStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionLiftPercentageAttribute( - CurrentPositionLiftPercentageAttributeCallback callback - ) { + CurrentPositionLiftPercentageAttributeCallback callback) { readCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionLiftPercentageAttribute( - CurrentPositionLiftPercentageAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionLiftPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionLiftPercentageAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCurrentPositionLiftPercentageAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionTiltPercentageAttribute( - CurrentPositionTiltPercentageAttributeCallback callback - ) { + CurrentPositionTiltPercentageAttributeCallback callback) { readCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionTiltPercentageAttribute( - CurrentPositionTiltPercentageAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionTiltPercentageAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionTiltPercentageAttributeCallback callback, int minInterval, int maxInterval) { + subscribeCurrentPositionTiltPercentageAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readOperationalStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readOperationalStatusAttribute(IntegerAttributeCallback callback) { readOperationalStatusAttribute(chipClusterPtr, callback); } + public void subscribeOperationalStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeOperationalStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readTargetPositionLiftPercent100thsAttribute( - TargetPositionLiftPercent100thsAttributeCallback callback - ) { + TargetPositionLiftPercent100thsAttributeCallback callback) { readTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeTargetPositionLiftPercent100thsAttribute( - TargetPositionLiftPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeTargetPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + TargetPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeTargetPositionLiftPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readTargetPositionTiltPercent100thsAttribute( - TargetPositionTiltPercent100thsAttributeCallback callback - ) { + TargetPositionTiltPercent100thsAttributeCallback callback) { readTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeTargetPositionTiltPercent100thsAttribute( - TargetPositionTiltPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeTargetPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + TargetPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeTargetPositionTiltPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readEndProductTypeAttribute( - IntegerAttributeCallback callback - ) { + public void readEndProductTypeAttribute(IntegerAttributeCallback callback) { readEndProductTypeAttribute(chipClusterPtr, callback); } + public void subscribeEndProductTypeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeEndProductTypeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionLiftPercent100thsAttribute( - CurrentPositionLiftPercent100thsAttributeCallback callback - ) { + CurrentPositionLiftPercent100thsAttributeCallback callback) { readCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionLiftPercent100thsAttribute( - CurrentPositionLiftPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionLiftPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeCurrentPositionLiftPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } public void readCurrentPositionTiltPercent100thsAttribute( - CurrentPositionTiltPercent100thsAttributeCallback callback - ) { + CurrentPositionTiltPercent100thsAttributeCallback callback) { readCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback); } + public void subscribeCurrentPositionTiltPercent100thsAttribute( - CurrentPositionTiltPercent100thsAttributeCallback callback - , - int minInterval, int maxInterval) { - subscribeCurrentPositionTiltPercent100thsAttribute(chipClusterPtr, callback, minInterval, maxInterval); + CurrentPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval) { + subscribeCurrentPositionTiltPercent100thsAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledOpenLimitLiftAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledOpenLimitLiftAttribute(IntegerAttributeCallback callback) { readInstalledOpenLimitLiftAttribute(chipClusterPtr, callback); } + public void subscribeInstalledOpenLimitLiftAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInstalledOpenLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledClosedLimitLiftAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledClosedLimitLiftAttribute(IntegerAttributeCallback callback) { readInstalledClosedLimitLiftAttribute(chipClusterPtr, callback); } + public void subscribeInstalledClosedLimitLiftAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeInstalledClosedLimitLiftAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeInstalledClosedLimitLiftAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledOpenLimitTiltAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledOpenLimitTiltAttribute(IntegerAttributeCallback callback) { readInstalledOpenLimitTiltAttribute(chipClusterPtr, callback); } + public void subscribeInstalledOpenLimitTiltAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeInstalledOpenLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readInstalledClosedLimitTiltAttribute( - IntegerAttributeCallback callback - ) { + public void readInstalledClosedLimitTiltAttribute(IntegerAttributeCallback callback) { readInstalledClosedLimitTiltAttribute(chipClusterPtr, callback); } + public void subscribeInstalledClosedLimitTiltAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { - subscribeInstalledClosedLimitTiltAttribute(chipClusterPtr, callback, minInterval, maxInterval); + IntegerAttributeCallback callback, int minInterval, int maxInterval) { + subscribeInstalledClosedLimitTiltAttribute( + chipClusterPtr, callback, minInterval, maxInterval); } - public void readModeAttribute( - IntegerAttributeCallback callback - ) { + public void readModeAttribute(IntegerAttributeCallback callback) { readModeAttribute(chipClusterPtr, callback); } + public void writeModeAttribute(DefaultClusterCallback callback, Integer value) { writeModeAttribute(chipClusterPtr, callback, value, null); } - public void writeModeAttribute(DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { + public void writeModeAttribute( + DefaultClusterCallback callback, Integer value, int timedWriteTimeoutMs) { writeModeAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); } + public void subscribeModeAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeModeAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readSafetyStatusAttribute( - IntegerAttributeCallback callback - ) { + public void readSafetyStatusAttribute(IntegerAttributeCallback callback) { readSafetyStatusAttribute(chipClusterPtr, callback); } + public void subscribeSafetyStatusAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeSafetyStatusAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readAttributeListAttribute( - AttributeListAttributeCallback callback - ) { + public void readAttributeListAttribute(AttributeListAttributeCallback callback) { readAttributeListAttribute(chipClusterPtr, callback); } + public void subscribeAttributeListAttribute( - AttributeListAttributeCallback callback - , - int minInterval, int maxInterval) { + AttributeListAttributeCallback callback, int minInterval, int maxInterval) { subscribeAttributeListAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readFeatureMapAttribute( - LongAttributeCallback callback - ) { + public void readFeatureMapAttribute(LongAttributeCallback callback) { readFeatureMapAttribute(chipClusterPtr, callback); } + public void subscribeFeatureMapAttribute( - LongAttributeCallback callback -, - int minInterval, int maxInterval) { + LongAttributeCallback callback, int minInterval, int maxInterval) { subscribeFeatureMapAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - public void readClusterRevisionAttribute( - IntegerAttributeCallback callback - ) { + public void readClusterRevisionAttribute(IntegerAttributeCallback callback) { readClusterRevisionAttribute(chipClusterPtr, callback); } + public void subscribeClusterRevisionAttribute( - IntegerAttributeCallback callback -, - int minInterval, int maxInterval) { + IntegerAttributeCallback callback, int minInterval, int maxInterval) { subscribeClusterRevisionAttribute(chipClusterPtr, callback, minInterval, maxInterval); } - private native void readTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftAttribute(long chipClusterPtr, - CurrentPositionLiftAttributeCallback callback - ); - private native void subscribeCurrentPositionLiftAttribute(long chipClusterPtr, - CurrentPositionLiftAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentPositionTiltAttribute(long chipClusterPtr, - CurrentPositionTiltAttributeCallback callback - ); - private native void subscribeCurrentPositionTiltAttribute(long chipClusterPtr, - CurrentPositionTiltAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readConfigStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeConfigStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftPercentageAttribute(long chipClusterPtr, - CurrentPositionLiftPercentageAttributeCallback callback - ); - private native void subscribeCurrentPositionLiftPercentageAttribute(long chipClusterPtr, - CurrentPositionLiftPercentageAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentPositionTiltPercentageAttribute(long chipClusterPtr, - CurrentPositionTiltPercentageAttributeCallback callback - ); - private native void subscribeCurrentPositionTiltPercentageAttribute(long chipClusterPtr, - CurrentPositionTiltPercentageAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readOperationalStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeOperationalStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, - TargetPositionLiftPercent100thsAttributeCallback callback - ); - private native void subscribeTargetPositionLiftPercent100thsAttribute(long chipClusterPtr, - TargetPositionLiftPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, - TargetPositionTiltPercent100thsAttributeCallback callback - ); - private native void subscribeTargetPositionTiltPercent100thsAttribute(long chipClusterPtr, - TargetPositionTiltPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readEndProductTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeEndProductTypeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, - CurrentPositionLiftPercent100thsAttributeCallback callback - ); - private native void subscribeCurrentPositionLiftPercent100thsAttribute(long chipClusterPtr, - CurrentPositionLiftPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, - CurrentPositionTiltPercent100thsAttributeCallback callback - ); - private native void subscribeCurrentPositionTiltPercent100thsAttribute(long chipClusterPtr, - CurrentPositionTiltPercent100thsAttributeCallback callback - , int minInterval, int maxInterval); - - private native void readInstalledOpenLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledOpenLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInstalledClosedLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledClosedLimitLiftAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInstalledOpenLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledOpenLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readInstalledClosedLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeInstalledClosedLimitTiltAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - - private native void writeModeAttribute(long chipClusterPtr, DefaultClusterCallback callback, Integer value, @Nullable Integer timedWriteTimeoutMs); - private native void subscribeModeAttribute(long chipClusterPtr, - IntegerAttributeCallback callback -, int minInterval, int maxInterval); - - private native void readSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback callback - ); - private native void subscribeSafetyStatusAttribute(long chipClusterPtr, - IntegerAttributeCallback 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); + private native void readTypeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftAttribute( + long chipClusterPtr, CurrentPositionLiftAttributeCallback callback); + + private native void subscribeCurrentPositionLiftAttribute( + long chipClusterPtr, + CurrentPositionLiftAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentPositionTiltAttribute( + long chipClusterPtr, CurrentPositionTiltAttributeCallback callback); + + private native void subscribeCurrentPositionTiltAttribute( + long chipClusterPtr, + CurrentPositionTiltAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readConfigStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeConfigStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercentageAttribute( + long chipClusterPtr, CurrentPositionLiftPercentageAttributeCallback callback); + + private native void subscribeCurrentPositionLiftPercentageAttribute( + long chipClusterPtr, + CurrentPositionLiftPercentageAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentPositionTiltPercentageAttribute( + long chipClusterPtr, CurrentPositionTiltPercentageAttributeCallback callback); + + private native void subscribeCurrentPositionTiltPercentageAttribute( + long chipClusterPtr, + CurrentPositionTiltPercentageAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readOperationalStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeOperationalStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readTargetPositionLiftPercent100thsAttribute( + long chipClusterPtr, TargetPositionLiftPercent100thsAttributeCallback callback); + + private native void subscribeTargetPositionLiftPercent100thsAttribute( + long chipClusterPtr, + TargetPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readTargetPositionTiltPercent100thsAttribute( + long chipClusterPtr, TargetPositionTiltPercent100thsAttributeCallback callback); + + private native void subscribeTargetPositionTiltPercent100thsAttribute( + long chipClusterPtr, + TargetPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readEndProductTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeEndProductTypeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readCurrentPositionLiftPercent100thsAttribute( + long chipClusterPtr, CurrentPositionLiftPercent100thsAttributeCallback callback); + + private native void subscribeCurrentPositionLiftPercent100thsAttribute( + long chipClusterPtr, + CurrentPositionLiftPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readCurrentPositionTiltPercent100thsAttribute( + long chipClusterPtr, CurrentPositionTiltPercent100thsAttributeCallback callback); + + private native void subscribeCurrentPositionTiltPercent100thsAttribute( + long chipClusterPtr, + CurrentPositionTiltPercent100thsAttributeCallback callback, + int minInterval, + int maxInterval); + + private native void readInstalledOpenLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledOpenLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledClosedLimitLiftAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInstalledOpenLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledOpenLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readInstalledClosedLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeInstalledClosedLimitTiltAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readModeAttribute(long chipClusterPtr, IntegerAttributeCallback callback); + + private native void writeModeAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + Integer value, + @Nullable Integer timedWriteTimeoutMs); + + private native void subscribeModeAttribute( + long chipClusterPtr, IntegerAttributeCallback callback, int minInterval, int maxInterval); + + private native void readSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback callback); + + private native void subscribeSafetyStatusAttribute( + long chipClusterPtr, IntegerAttributeCallback 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); } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java index 19853055a448c2..bbbf6488468e15 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipStructs.java @@ -24,2110 +24,1975 @@ import java.util.Optional; public class ChipStructs { -public static class AccessControlClusterTarget { -public @Nullable Long cluster; -public @Nullable Integer endpoint; -public @Nullable Long deviceType; - - public AccessControlClusterTarget( - @Nullable Long cluster - , @Nullable Integer endpoint - , @Nullable Long deviceType - ) { - this.cluster = cluster; - this.endpoint = endpoint; - this.deviceType = deviceType; + public static class AccessControlClusterTarget { + public @Nullable Long cluster; + public @Nullable Integer endpoint; + public @Nullable Long deviceType; + + public AccessControlClusterTarget( + @Nullable Long cluster, @Nullable Integer endpoint, @Nullable Long deviceType) { + this.cluster = cluster; + this.endpoint = endpoint; + this.deviceType = deviceType; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterTarget {\n"); + output.append("\tcluster: "); + output.append(cluster); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("\tdeviceType: "); + output.append(deviceType); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class AccessControlClusterAccessControlEntry { + public Integer fabricIndex; + public Integer privilege; + public Integer authMode; + public @Nullable ArrayList subjects; + public @Nullable ArrayList targets; + + public AccessControlClusterAccessControlEntry( + Integer fabricIndex, + Integer privilege, + Integer authMode, + @Nullable ArrayList subjects, + @Nullable ArrayList targets) { + this.fabricIndex = fabricIndex; + this.privilege = privilege; + this.authMode = authMode; + this.subjects = subjects; + this.targets = targets; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterAccessControlEntry {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tprivilege: "); + output.append(privilege); + output.append("\n"); + output.append("\tauthMode: "); + output.append(authMode); + output.append("\n"); + output.append("\tsubjects: "); + output.append(subjects); + output.append("\n"); + output.append("\ttargets: "); + output.append(targets); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class AccessControlClusterExtensionEntry { + public Integer fabricIndex; + public byte[] data; + + public AccessControlClusterExtensionEntry(Integer fabricIndex, byte[] data) { + this.fabricIndex = fabricIndex; + this.data = data; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AccessControlClusterExtensionEntry {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tdata: "); + output.append(Arrays.toString(data)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ApplicationBasicClusterApplicationBasicApplication { + public Integer catalogVendorId; + public String applicationId; + + public ApplicationBasicClusterApplicationBasicApplication( + Integer catalogVendorId, String applicationId) { + this.catalogVendorId = catalogVendorId; + this.applicationId = applicationId; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationBasicClusterApplicationBasicApplication {\n"); + output.append("\tcatalogVendorId: "); + output.append(catalogVendorId); + output.append("\n"); + output.append("\tapplicationId: "); + output.append(applicationId); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ApplicationLauncherClusterApplicationLauncherApplication { + public Integer catalogVendorId; + public String applicationId; + + public ApplicationLauncherClusterApplicationLauncherApplication( + Integer catalogVendorId, String applicationId) { + this.catalogVendorId = catalogVendorId; + this.applicationId = applicationId; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationLauncherClusterApplicationLauncherApplication {\n"); + output.append("\tcatalogVendorId: "); + output.append(catalogVendorId); + output.append("\n"); + output.append("\tapplicationId: "); + output.append(applicationId); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ApplicationLauncherClusterApplicationEP { + public ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application; + public String endpoint; + + public ApplicationLauncherClusterApplicationEP( + ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application, + String endpoint) { + this.application = application; + this.endpoint = endpoint; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ApplicationLauncherClusterApplicationEP {\n"); + output.append("\tapplication: "); + output.append(application); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class AudioOutputClusterOutputInfo { + public Integer index; + public Integer outputType; + public String name; + + public AudioOutputClusterOutputInfo(Integer index, Integer outputType, String name) { + this.index = index; + this.outputType = outputType; + this.name = name; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("AudioOutputClusterOutputInfo {\n"); + output.append("\tindex: "); + output.append(index); + output.append("\n"); + output.append("\toutputType: "); + output.append(outputType); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class BridgedActionsClusterActionStruct { + public Integer actionID; + public String name; + public Integer type; + public Integer endpointListID; + public Integer supportedCommands; + public Integer status; + + public BridgedActionsClusterActionStruct( + Integer actionID, + String name, + Integer type, + Integer endpointListID, + Integer supportedCommands, + Integer status) { + this.actionID = actionID; + this.name = name; + this.type = type; + this.endpointListID = endpointListID; + this.supportedCommands = supportedCommands; + this.status = status; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedActionsClusterActionStruct {\n"); + output.append("\tactionID: "); + output.append(actionID); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tendpointListID: "); + output.append(endpointListID); + output.append("\n"); + output.append("\tsupportedCommands: "); + output.append(supportedCommands); + output.append("\n"); + output.append("\tstatus: "); + output.append(status); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class BridgedActionsClusterEndpointListStruct { + public Integer endpointListID; + public String name; + public Integer type; + public ArrayList endpoints; + + public BridgedActionsClusterEndpointListStruct( + Integer endpointListID, String name, Integer type, ArrayList endpoints) { + this.endpointListID = endpointListID; + this.name = name; + this.type = type; + this.endpoints = endpoints; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("BridgedActionsClusterEndpointListStruct {\n"); + output.append("\tendpointListID: "); + output.append(endpointListID); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tendpoints: "); + output.append(endpoints); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ChannelClusterChannelInfo { + public Integer majorNumber; + public Integer minorNumber; + public String name; + public String callSign; + public String affiliateCallSign; + + public ChannelClusterChannelInfo( + Integer majorNumber, + Integer minorNumber, + String name, + String callSign, + String affiliateCallSign) { + this.majorNumber = majorNumber; + this.minorNumber = minorNumber; + this.name = name; + this.callSign = callSign; + this.affiliateCallSign = affiliateCallSign; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ChannelClusterChannelInfo {\n"); + output.append("\tmajorNumber: "); + output.append(majorNumber); + output.append("\n"); + output.append("\tminorNumber: "); + output.append(minorNumber); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tcallSign: "); + output.append(callSign); + output.append("\n"); + output.append("\taffiliateCallSign: "); + output.append(affiliateCallSign); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ChannelClusterLineupInfo { + public String operatorName; + public String lineupName; + public String postalCode; + public Integer lineupInfoType; + + public ChannelClusterLineupInfo( + String operatorName, String lineupName, String postalCode, Integer lineupInfoType) { + this.operatorName = operatorName; + this.lineupName = lineupName; + this.postalCode = postalCode; + this.lineupInfoType = lineupInfoType; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ChannelClusterLineupInfo {\n"); + output.append("\toperatorName: "); + output.append(operatorName); + output.append("\n"); + output.append("\tlineupName: "); + output.append(lineupName); + output.append("\n"); + output.append("\tpostalCode: "); + output.append(postalCode); + output.append("\n"); + output.append("\tlineupInfoType: "); + output.append(lineupInfoType); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterDimension { + public Double width; + public Double height; + public Integer metric; + + public ContentLauncherClusterDimension(Double width, Double height, Integer metric) { + this.width = width; + this.height = height; + this.metric = metric; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterDimension {\n"); + output.append("\twidth: "); + output.append(width); + output.append("\n"); + output.append("\theight: "); + output.append(height); + output.append("\n"); + output.append("\tmetric: "); + output.append(metric); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterAdditionalInfo { + public String name; + public String value; + + public ContentLauncherClusterAdditionalInfo(String name, String value) { + this.name = name; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterAdditionalInfo {\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterParameter { + public Integer type; + public String value; + public ArrayList externalIDList; + + public ContentLauncherClusterParameter( + Integer type, + String value, + ArrayList externalIDList) { + this.type = type; + this.value = value; + this.externalIDList = externalIDList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterParameter {\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("\texternalIDList: "); + output.append(externalIDList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterContentSearch { + public ArrayList parameterList; + + public ContentLauncherClusterContentSearch( + ArrayList parameterList) { + this.parameterList = parameterList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterContentSearch {\n"); + output.append("\tparameterList: "); + output.append(parameterList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterStyleInformation { + public String imageUrl; + public String color; + public ChipStructs.ContentLauncherClusterDimension size; + + public ContentLauncherClusterStyleInformation( + String imageUrl, String color, ChipStructs.ContentLauncherClusterDimension size) { + this.imageUrl = imageUrl; + this.color = color; + this.size = size; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterStyleInformation {\n"); + output.append("\timageUrl: "); + output.append(imageUrl); + output.append("\n"); + output.append("\tcolor: "); + output.append(color); + output.append("\n"); + output.append("\tsize: "); + output.append(size); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ContentLauncherClusterBrandingInformation { + public String providerName; + public ChipStructs.ContentLauncherClusterStyleInformation background; + public ChipStructs.ContentLauncherClusterStyleInformation logo; + public ChipStructs.ContentLauncherClusterStyleInformation progressBar; + public ChipStructs.ContentLauncherClusterStyleInformation splash; + public ChipStructs.ContentLauncherClusterStyleInformation waterMark; + + public ContentLauncherClusterBrandingInformation( + String providerName, + ChipStructs.ContentLauncherClusterStyleInformation background, + ChipStructs.ContentLauncherClusterStyleInformation logo, + ChipStructs.ContentLauncherClusterStyleInformation progressBar, + ChipStructs.ContentLauncherClusterStyleInformation splash, + ChipStructs.ContentLauncherClusterStyleInformation waterMark) { + this.providerName = providerName; + this.background = background; + this.logo = logo; + this.progressBar = progressBar; + this.splash = splash; + this.waterMark = waterMark; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ContentLauncherClusterBrandingInformation {\n"); + output.append("\tproviderName: "); + output.append(providerName); + output.append("\n"); + output.append("\tbackground: "); + output.append(background); + output.append("\n"); + output.append("\tlogo: "); + output.append(logo); + output.append("\n"); + output.append("\tprogressBar: "); + output.append(progressBar); + output.append("\n"); + output.append("\tsplash: "); + output.append(splash); + output.append("\n"); + output.append("\twaterMark: "); + output.append(waterMark); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class DescriptorClusterDeviceType { + public Long type; + public Integer revision; + + public DescriptorClusterDeviceType(Long type, Integer revision) { + this.type = type; + this.revision = revision; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DescriptorClusterDeviceType {\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("\trevision: "); + output.append(revision); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class DoorLockClusterDlCredential { + public Integer credentialType; + public Integer credentialIndex; + + public DoorLockClusterDlCredential(Integer credentialType, Integer credentialIndex) { + this.credentialType = credentialType; + this.credentialIndex = credentialIndex; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("DoorLockClusterDlCredential {\n"); + output.append("\tcredentialType: "); + output.append(credentialType); + output.append("\n"); + output.append("\tcredentialIndex: "); + output.append(credentialIndex); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class FixedLabelClusterLabelStruct { + public String label; + public String value; + + public FixedLabelClusterLabelStruct(String label, String value) { + this.label = label; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("FixedLabelClusterLabelStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GeneralCommissioningClusterBasicCommissioningInfoType { + public Long failSafeExpiryLengthMs; + + public GeneralCommissioningClusterBasicCommissioningInfoType(Long failSafeExpiryLengthMs) { + this.failSafeExpiryLengthMs = failSafeExpiryLengthMs; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GeneralCommissioningClusterBasicCommissioningInfoType {\n"); + output.append("\tfailSafeExpiryLengthMs: "); + output.append(failSafeExpiryLengthMs); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GeneralDiagnosticsClusterNetworkInterfaceType { + public String name; + public Boolean fabricConnected; + public Boolean offPremiseServicesReachableIPv4; + public Boolean offPremiseServicesReachableIPv6; + public byte[] hardwareAddress; + public Integer type; + + public GeneralDiagnosticsClusterNetworkInterfaceType( + String name, + Boolean fabricConnected, + Boolean offPremiseServicesReachableIPv4, + Boolean offPremiseServicesReachableIPv6, + byte[] hardwareAddress, + Integer type) { + this.name = name; + this.fabricConnected = fabricConnected; + this.offPremiseServicesReachableIPv4 = offPremiseServicesReachableIPv4; + this.offPremiseServicesReachableIPv6 = offPremiseServicesReachableIPv6; + this.hardwareAddress = hardwareAddress; + this.type = type; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GeneralDiagnosticsClusterNetworkInterfaceType {\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tfabricConnected: "); + output.append(fabricConnected); + output.append("\n"); + output.append("\toffPremiseServicesReachableIPv4: "); + output.append(offPremiseServicesReachableIPv4); + output.append("\n"); + output.append("\toffPremiseServicesReachableIPv6: "); + output.append(offPremiseServicesReachableIPv6); + output.append("\n"); + output.append("\thardwareAddress: "); + output.append(Arrays.toString(hardwareAddress)); + output.append("\n"); + output.append("\ttype: "); + output.append(type); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GroupKeyManagementClusterGroupInfo { + public Integer fabricIndex; + public Integer groupId; + public ArrayList endpoints; + public String groupName; + + public GroupKeyManagementClusterGroupInfo( + Integer fabricIndex, Integer groupId, ArrayList endpoints, String groupName) { + this.fabricIndex = fabricIndex; + this.groupId = groupId; + this.endpoints = endpoints; + this.groupName = groupName; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupInfo {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tgroupId: "); + output.append(groupId); + output.append("\n"); + output.append("\tendpoints: "); + output.append(endpoints); + output.append("\n"); + output.append("\tgroupName: "); + output.append(groupName); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GroupKeyManagementClusterGroupKey { + public Integer fabricIndex; + public Integer groupId; + public Integer groupKeySetID; + + public GroupKeyManagementClusterGroupKey( + Integer fabricIndex, Integer groupId, Integer groupKeySetID) { + this.fabricIndex = fabricIndex; + this.groupId = groupId; + this.groupKeySetID = groupKeySetID; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupKey {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tgroupId: "); + output.append(groupId); + output.append("\n"); + output.append("\tgroupKeySetID: "); + output.append(groupKeySetID); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class GroupKeyManagementClusterGroupKeySet { + public Integer groupKeySetID; + public Integer securityPolicy; + public byte[] epochKey0; + public Long epochStartTime0; + public byte[] epochKey1; + public Long epochStartTime1; + public byte[] epochKey2; + public Long epochStartTime2; + + public GroupKeyManagementClusterGroupKeySet( + Integer groupKeySetID, + Integer securityPolicy, + byte[] epochKey0, + Long epochStartTime0, + byte[] epochKey1, + Long epochStartTime1, + byte[] epochKey2, + Long epochStartTime2) { + this.groupKeySetID = groupKeySetID; + this.securityPolicy = securityPolicy; + this.epochKey0 = epochKey0; + this.epochStartTime0 = epochStartTime0; + this.epochKey1 = epochKey1; + this.epochStartTime1 = epochStartTime1; + this.epochKey2 = epochKey2; + this.epochStartTime2 = epochStartTime2; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("GroupKeyManagementClusterGroupKeySet {\n"); + output.append("\tgroupKeySetID: "); + output.append(groupKeySetID); + output.append("\n"); + output.append("\tsecurityPolicy: "); + output.append(securityPolicy); + output.append("\n"); + output.append("\tepochKey0: "); + output.append(Arrays.toString(epochKey0)); + output.append("\n"); + output.append("\tepochStartTime0: "); + output.append(epochStartTime0); + output.append("\n"); + output.append("\tepochKey1: "); + output.append(Arrays.toString(epochKey1)); + output.append("\n"); + output.append("\tepochStartTime1: "); + output.append(epochStartTime1); + output.append("\n"); + output.append("\tepochKey2: "); + output.append(Arrays.toString(epochKey2)); + output.append("\n"); + output.append("\tepochStartTime2: "); + output.append(epochStartTime2); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class MediaInputClusterInputInfo { + public Integer index; + public Integer inputType; + public String name; + public String description; + + public MediaInputClusterInputInfo( + Integer index, Integer inputType, String name, String description) { + this.index = index; + this.inputType = inputType; + this.name = name; + this.description = description; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("MediaInputClusterInputInfo {\n"); + output.append("\tindex: "); + output.append(index); + output.append("\n"); + output.append("\tinputType: "); + output.append(inputType); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tdescription: "); + output.append(description); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class MediaPlaybackClusterPlaybackPosition { + public Long updatedAt; + public Long position; + + public MediaPlaybackClusterPlaybackPosition(Long updatedAt, Long position) { + this.updatedAt = updatedAt; + this.position = position; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("MediaPlaybackClusterPlaybackPosition {\n"); + output.append("\tupdatedAt: "); + output.append(updatedAt); + output.append("\n"); + output.append("\tposition: "); + output.append(position); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ModeSelectClusterModeOptionStruct { + public String label; + public Integer mode; + public Long semanticTag; + + public ModeSelectClusterModeOptionStruct(String label, Integer mode, Long semanticTag) { + this.label = label; + this.mode = mode; + this.semanticTag = semanticTag; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ModeSelectClusterModeOptionStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tmode: "); + output.append(mode); + output.append("\n"); + output.append("\tsemanticTag: "); + output.append(semanticTag); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ModeSelectClusterSemanticTag { + public Integer mfgCode; + public Integer value; + + public ModeSelectClusterSemanticTag(Integer mfgCode, Integer value) { + this.mfgCode = mfgCode; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ModeSelectClusterSemanticTag {\n"); + output.append("\tmfgCode: "); + output.append(mfgCode); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class NetworkCommissioningClusterNetworkInfo { + public byte[] networkID; + public Boolean connected; + + public NetworkCommissioningClusterNetworkInfo(byte[] networkID, Boolean connected) { + this.networkID = networkID; + this.connected = connected; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterNetworkInfo {\n"); + output.append("\tnetworkID: "); + output.append(Arrays.toString(networkID)); + output.append("\n"); + output.append("\tconnected: "); + output.append(connected); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class NetworkCommissioningClusterThreadInterfaceScanResult { + public Long panId; + public Long extendedPanId; + public String networkName; + public Integer channel; + public Integer version; + public Long extendedAddress; + public Integer rssi; + public Integer lqi; + + public NetworkCommissioningClusterThreadInterfaceScanResult( + Long panId, + Long extendedPanId, + String networkName, + Integer channel, + Integer version, + Long extendedAddress, + Integer rssi, + Integer lqi) { + this.panId = panId; + this.extendedPanId = extendedPanId; + this.networkName = networkName; + this.channel = channel; + this.version = version; + this.extendedAddress = extendedAddress; + this.rssi = rssi; + this.lqi = lqi; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterThreadInterfaceScanResult {\n"); + output.append("\tpanId: "); + output.append(panId); + output.append("\n"); + output.append("\textendedPanId: "); + output.append(extendedPanId); + output.append("\n"); + output.append("\tnetworkName: "); + output.append(networkName); + output.append("\n"); + output.append("\tchannel: "); + output.append(channel); + output.append("\n"); + output.append("\tversion: "); + output.append(version); + output.append("\n"); + output.append("\textendedAddress: "); + output.append(extendedAddress); + output.append("\n"); + output.append("\trssi: "); + output.append(rssi); + output.append("\n"); + output.append("\tlqi: "); + output.append(lqi); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class NetworkCommissioningClusterWiFiInterfaceScanResult { + public Integer security; + public byte[] ssid; + public byte[] bssid; + public Integer channel; + public Integer wiFiBand; + public Integer rssi; + + public NetworkCommissioningClusterWiFiInterfaceScanResult( + Integer security, + byte[] ssid, + byte[] bssid, + Integer channel, + Integer wiFiBand, + Integer rssi) { + this.security = security; + this.ssid = ssid; + this.bssid = bssid; + this.channel = channel; + this.wiFiBand = wiFiBand; + this.rssi = rssi; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("NetworkCommissioningClusterWiFiInterfaceScanResult {\n"); + output.append("\tsecurity: "); + output.append(security); + output.append("\n"); + output.append("\tssid: "); + output.append(Arrays.toString(ssid)); + output.append("\n"); + output.append("\tbssid: "); + output.append(Arrays.toString(bssid)); + output.append("\n"); + output.append("\tchannel: "); + output.append(channel); + output.append("\n"); + output.append("\twiFiBand: "); + output.append(wiFiBand); + output.append("\n"); + output.append("\trssi: "); + output.append(rssi); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class OtaSoftwareUpdateRequestorClusterProviderLocation { + public Integer fabricIndex; + public Long providerNodeID; + public Integer endpoint; + + public OtaSoftwareUpdateRequestorClusterProviderLocation( + Integer fabricIndex, Long providerNodeID, Integer endpoint) { + this.fabricIndex = fabricIndex; + this.providerNodeID = providerNodeID; + this.endpoint = endpoint; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OtaSoftwareUpdateRequestorClusterProviderLocation {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tproviderNodeID: "); + output.append(providerNodeID); + output.append("\n"); + output.append("\tendpoint: "); + output.append(endpoint); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class OperationalCredentialsClusterFabricDescriptor { + public Integer fabricIndex; + public byte[] rootPublicKey; + public Integer vendorId; + public Long fabricId; + public Long nodeId; + public String label; + + public OperationalCredentialsClusterFabricDescriptor( + Integer fabricIndex, + byte[] rootPublicKey, + Integer vendorId, + Long fabricId, + Long nodeId, + String label) { + this.fabricIndex = fabricIndex; + this.rootPublicKey = rootPublicKey; + this.vendorId = vendorId; + this.fabricId = fabricId; + this.nodeId = nodeId; + this.label = label; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OperationalCredentialsClusterFabricDescriptor {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\trootPublicKey: "); + output.append(Arrays.toString(rootPublicKey)); + output.append("\n"); + output.append("\tvendorId: "); + output.append(vendorId); + output.append("\n"); + output.append("\tfabricId: "); + output.append(fabricId); + output.append("\n"); + output.append("\tnodeId: "); + output.append(nodeId); + output.append("\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class OperationalCredentialsClusterNOCStruct { + public Integer fabricIndex; + public byte[] noc; + public @Nullable byte[] icac; + + public OperationalCredentialsClusterNOCStruct( + Integer fabricIndex, byte[] noc, @Nullable byte[] icac) { + this.fabricIndex = fabricIndex; + this.noc = noc; + this.icac = icac; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("OperationalCredentialsClusterNOCStruct {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\tnoc: "); + output.append(Arrays.toString(noc)); + output.append("\n"); + output.append("\ticac: "); + output.append(Arrays.toString(icac)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class PowerSourceClusterBatChargeFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterBatChargeFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatChargeFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class PowerSourceClusterBatFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterBatFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterBatFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class PowerSourceClusterWiredFaultChangeType { + public ArrayList current; + public ArrayList previous; + + public PowerSourceClusterWiredFaultChangeType( + ArrayList current, ArrayList previous) { + this.current = current; + this.previous = previous; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("PowerSourceClusterWiredFaultChangeType {\n"); + output.append("\tcurrent: "); + output.append(current); + output.append("\n"); + output.append("\tprevious: "); + output.append(previous); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ScenesClusterSceneExtensionFieldSet { + public Long clusterId; + public Integer length; + public Integer value; + + public ScenesClusterSceneExtensionFieldSet(Long clusterId, Integer length, Integer value) { + this.clusterId = clusterId; + this.length = length; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ScenesClusterSceneExtensionFieldSet {\n"); + output.append("\tclusterId: "); + output.append(clusterId); + output.append("\n"); + output.append("\tlength: "); + output.append(length); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SoftwareDiagnosticsClusterSoftwareFaultStruct { + public Long id; + public String name; + public byte[] faultRecording; + + public SoftwareDiagnosticsClusterSoftwareFaultStruct( + Long id, String name, byte[] faultRecording) { + this.id = id; + this.name = name; + this.faultRecording = faultRecording; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SoftwareDiagnosticsClusterSoftwareFaultStruct {\n"); + output.append("\tid: "); + output.append(id); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tfaultRecording: "); + output.append(Arrays.toString(faultRecording)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class SoftwareDiagnosticsClusterThreadMetrics { + public Long id; + public String name; + public Long stackFreeCurrent; + public Long stackFreeMinimum; + public Long stackSize; + + public SoftwareDiagnosticsClusterThreadMetrics( + Long id, String name, Long stackFreeCurrent, Long stackFreeMinimum, Long stackSize) { + this.id = id; + this.name = name; + this.stackFreeCurrent = stackFreeCurrent; + this.stackFreeMinimum = stackFreeMinimum; + this.stackSize = stackSize; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("SoftwareDiagnosticsClusterThreadMetrics {\n"); + output.append("\tid: "); + output.append(id); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("\tstackFreeCurrent: "); + output.append(stackFreeCurrent); + output.append("\n"); + output.append("\tstackFreeMinimum: "); + output.append(stackFreeMinimum); + output.append("\n"); + output.append("\tstackSize: "); + output.append(stackSize); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TargetNavigatorClusterTargetInfo { + public Integer identifier; + public String name; + + public TargetNavigatorClusterTargetInfo(Integer identifier, String name) { + this.identifier = identifier; + this.name = name; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TargetNavigatorClusterTargetInfo {\n"); + output.append("\tidentifier: "); + output.append(identifier); + output.append("\n"); + output.append("\tname: "); + output.append(name); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterSimpleStruct { + public Integer a; + public Boolean b; + public Integer c; + public byte[] d; + public String e; + public Integer f; + public Float g; + public Double h; + + public TestClusterClusterSimpleStruct( + Integer a, Boolean b, Integer c, byte[] d, String e, Integer f, Float g, Double h) { + this.a = a; + this.b = b; + this.c = c; + this.d = d; + this.e = e; + this.f = f; + this.g = g; + this.h = h; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterSimpleStruct {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("\td: "); + output.append(Arrays.toString(d)); + output.append("\n"); + output.append("\te: "); + output.append(e); + output.append("\n"); + output.append("\tf: "); + output.append(f); + output.append("\n"); + output.append("\tg: "); + output.append(g); + output.append("\n"); + output.append("\th: "); + output.append(h); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterNullablesAndOptionalsStruct { + public @Nullable Integer nullableInt; + public Optional optionalInt; + public @Nullable Optional nullableOptionalInt; + public @Nullable String nullableString; + public Optional optionalString; + public @Nullable Optional nullableOptionalString; + public @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct; + public Optional optionalStruct; + public @Nullable Optional nullableOptionalStruct; + public @Nullable ArrayList nullableList; + public Optional> optionalList; + public @Nullable Optional> nullableOptionalList; + + public TestClusterClusterNullablesAndOptionalsStruct( + @Nullable Integer nullableInt, + Optional optionalInt, + @Nullable Optional nullableOptionalInt, + @Nullable String nullableString, + Optional optionalString, + @Nullable Optional nullableOptionalString, + @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct, + Optional optionalStruct, + @Nullable Optional nullableOptionalStruct, + @Nullable ArrayList nullableList, + Optional> optionalList, + @Nullable Optional> nullableOptionalList) { + this.nullableInt = nullableInt; + this.optionalInt = optionalInt; + this.nullableOptionalInt = nullableOptionalInt; + this.nullableString = nullableString; + this.optionalString = optionalString; + this.nullableOptionalString = nullableOptionalString; + this.nullableStruct = nullableStruct; + this.optionalStruct = optionalStruct; + this.nullableOptionalStruct = nullableOptionalStruct; + this.nullableList = nullableList; + this.optionalList = optionalList; + this.nullableOptionalList = nullableOptionalList; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNullablesAndOptionalsStruct {\n"); + output.append("\tnullableInt: "); + output.append(nullableInt); + output.append("\n"); + output.append("\toptionalInt: "); + output.append(optionalInt); + output.append("\n"); + output.append("\tnullableOptionalInt: "); + output.append(nullableOptionalInt); + output.append("\n"); + output.append("\tnullableString: "); + output.append(nullableString); + output.append("\n"); + output.append("\toptionalString: "); + output.append(optionalString); + output.append("\n"); + output.append("\tnullableOptionalString: "); + output.append(nullableOptionalString); + output.append("\n"); + output.append("\tnullableStruct: "); + output.append(nullableStruct); + output.append("\n"); + output.append("\toptionalStruct: "); + output.append(optionalStruct); + output.append("\n"); + output.append("\tnullableOptionalStruct: "); + output.append(nullableOptionalStruct); + output.append("\n"); + output.append("\tnullableList: "); + output.append(nullableList); + output.append("\n"); + output.append("\toptionalList: "); + output.append(optionalList); + output.append("\n"); + output.append("\tnullableOptionalList: "); + output.append(nullableOptionalList); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterNestedStruct { + public Integer a; + public Boolean b; + public ChipStructs.TestClusterClusterSimpleStruct c; + + public TestClusterClusterNestedStruct( + Integer a, Boolean b, ChipStructs.TestClusterClusterSimpleStruct c) { + this.a = a; + this.b = b; + this.c = c; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNestedStruct {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterNestedStructList { + public Integer a; + public Boolean b; + public ChipStructs.TestClusterClusterSimpleStruct c; + public ArrayList d; + public ArrayList e; + public ArrayList f; + public ArrayList g; + + public TestClusterClusterNestedStructList( + Integer a, + Boolean b, + ChipStructs.TestClusterClusterSimpleStruct c, + ArrayList d, + ArrayList e, + ArrayList f, + ArrayList g) { + this.a = a; + this.b = b; + this.c = c; + this.d = d; + this.e = e; + this.f = f; + this.g = g; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterNestedStructList {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("\tb: "); + output.append(b); + output.append("\n"); + output.append("\tc: "); + output.append(c); + output.append("\n"); + output.append("\td: "); + output.append(d); + output.append("\n"); + output.append("\te: "); + output.append(e); + output.append("\n"); + output.append("\tf: "); + output.append(f); + output.append("\n"); + output.append("\tg: "); + output.append(g); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterDoubleNestedStructList { + public ArrayList a; + + public TestClusterClusterDoubleNestedStructList( + ArrayList a) { + this.a = a; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterDoubleNestedStructList {\n"); + output.append("\ta: "); + output.append(a); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterTestFabricScoped { + public Integer fabricIndex; + + public TestClusterClusterTestFabricScoped(Integer fabricIndex) { + this.fabricIndex = fabricIndex; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterTestFabricScoped {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class TestClusterClusterTestListStructOctet { + public Long fabricIndex; + public byte[] operationalCert; + + public TestClusterClusterTestListStructOctet(Long fabricIndex, byte[] operationalCert) { + this.fabricIndex = fabricIndex; + this.operationalCert = operationalCert; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("TestClusterClusterTestListStructOctet {\n"); + output.append("\tfabricIndex: "); + output.append(fabricIndex); + output.append("\n"); + output.append("\toperationalCert: "); + output.append(Arrays.toString(operationalCert)); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterNeighborTable { + public Long extAddress; + public Long age; + public Integer rloc16; + public Long linkFrameCounter; + public Long mleFrameCounter; + public Integer lqi; + public Integer averageRssi; + public Integer lastRssi; + public Integer frameErrorRate; + public Integer messageErrorRate; + public Boolean rxOnWhenIdle; + public Boolean fullThreadDevice; + public Boolean fullNetworkData; + public Boolean isChild; + + public ThreadNetworkDiagnosticsClusterNeighborTable( + Long extAddress, + Long age, + Integer rloc16, + Long linkFrameCounter, + Long mleFrameCounter, + Integer lqi, + Integer averageRssi, + Integer lastRssi, + Integer frameErrorRate, + Integer messageErrorRate, + Boolean rxOnWhenIdle, + Boolean fullThreadDevice, + Boolean fullNetworkData, + Boolean isChild) { + this.extAddress = extAddress; + this.age = age; + this.rloc16 = rloc16; + this.linkFrameCounter = linkFrameCounter; + this.mleFrameCounter = mleFrameCounter; + this.lqi = lqi; + this.averageRssi = averageRssi; + this.lastRssi = lastRssi; + this.frameErrorRate = frameErrorRate; + this.messageErrorRate = messageErrorRate; + this.rxOnWhenIdle = rxOnWhenIdle; + this.fullThreadDevice = fullThreadDevice; + this.fullNetworkData = fullNetworkData; + this.isChild = isChild; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterNeighborTable {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\tage: "); + output.append(age); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\tlinkFrameCounter: "); + output.append(linkFrameCounter); + output.append("\n"); + output.append("\tmleFrameCounter: "); + output.append(mleFrameCounter); + output.append("\n"); + output.append("\tlqi: "); + output.append(lqi); + output.append("\n"); + output.append("\taverageRssi: "); + output.append(averageRssi); + output.append("\n"); + output.append("\tlastRssi: "); + output.append(lastRssi); + output.append("\n"); + output.append("\tframeErrorRate: "); + output.append(frameErrorRate); + output.append("\n"); + output.append("\tmessageErrorRate: "); + output.append(messageErrorRate); + output.append("\n"); + output.append("\trxOnWhenIdle: "); + output.append(rxOnWhenIdle); + output.append("\n"); + output.append("\tfullThreadDevice: "); + output.append(fullThreadDevice); + output.append("\n"); + output.append("\tfullNetworkData: "); + output.append(fullNetworkData); + output.append("\n"); + output.append("\tisChild: "); + output.append(isChild); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterOperationalDatasetComponents { + public Boolean activeTimestampPresent; + public Boolean pendingTimestampPresent; + public Boolean masterKeyPresent; + public Boolean networkNamePresent; + public Boolean extendedPanIdPresent; + public Boolean meshLocalPrefixPresent; + public Boolean delayPresent; + public Boolean panIdPresent; + public Boolean channelPresent; + public Boolean pskcPresent; + public Boolean securityPolicyPresent; + public Boolean channelMaskPresent; + + public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents( + Boolean activeTimestampPresent, + Boolean pendingTimestampPresent, + Boolean masterKeyPresent, + Boolean networkNamePresent, + Boolean extendedPanIdPresent, + Boolean meshLocalPrefixPresent, + Boolean delayPresent, + Boolean panIdPresent, + Boolean channelPresent, + Boolean pskcPresent, + Boolean securityPolicyPresent, + Boolean channelMaskPresent) { + this.activeTimestampPresent = activeTimestampPresent; + this.pendingTimestampPresent = pendingTimestampPresent; + this.masterKeyPresent = masterKeyPresent; + this.networkNamePresent = networkNamePresent; + this.extendedPanIdPresent = extendedPanIdPresent; + this.meshLocalPrefixPresent = meshLocalPrefixPresent; + this.delayPresent = delayPresent; + this.panIdPresent = panIdPresent; + this.channelPresent = channelPresent; + this.pskcPresent = pskcPresent; + this.securityPolicyPresent = securityPolicyPresent; + this.channelMaskPresent = channelMaskPresent; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterOperationalDatasetComponents {\n"); + output.append("\tactiveTimestampPresent: "); + output.append(activeTimestampPresent); + output.append("\n"); + output.append("\tpendingTimestampPresent: "); + output.append(pendingTimestampPresent); + output.append("\n"); + output.append("\tmasterKeyPresent: "); + output.append(masterKeyPresent); + output.append("\n"); + output.append("\tnetworkNamePresent: "); + output.append(networkNamePresent); + output.append("\n"); + output.append("\textendedPanIdPresent: "); + output.append(extendedPanIdPresent); + output.append("\n"); + output.append("\tmeshLocalPrefixPresent: "); + output.append(meshLocalPrefixPresent); + output.append("\n"); + output.append("\tdelayPresent: "); + output.append(delayPresent); + output.append("\n"); + output.append("\tpanIdPresent: "); + output.append(panIdPresent); + output.append("\n"); + output.append("\tchannelPresent: "); + output.append(channelPresent); + output.append("\n"); + output.append("\tpskcPresent: "); + output.append(pskcPresent); + output.append("\n"); + output.append("\tsecurityPolicyPresent: "); + output.append(securityPolicyPresent); + output.append("\n"); + output.append("\tchannelMaskPresent: "); + output.append(channelMaskPresent); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterRouteTable { + public Long extAddress; + public Integer rloc16; + public Integer routerId; + public Integer nextHop; + public Integer pathCost; + public Integer LQIIn; + public Integer LQIOut; + public Integer age; + public Boolean allocated; + public Boolean linkEstablished; + + public ThreadNetworkDiagnosticsClusterRouteTable( + Long extAddress, + Integer rloc16, + Integer routerId, + Integer nextHop, + Integer pathCost, + Integer LQIIn, + Integer LQIOut, + Integer age, + Boolean allocated, + Boolean linkEstablished) { + this.extAddress = extAddress; + this.rloc16 = rloc16; + this.routerId = routerId; + this.nextHop = nextHop; + this.pathCost = pathCost; + this.LQIIn = LQIIn; + this.LQIOut = LQIOut; + this.age = age; + this.allocated = allocated; + this.linkEstablished = linkEstablished; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterRouteTable {\n"); + output.append("\textAddress: "); + output.append(extAddress); + output.append("\n"); + output.append("\trloc16: "); + output.append(rloc16); + output.append("\n"); + output.append("\trouterId: "); + output.append(routerId); + output.append("\n"); + output.append("\tnextHop: "); + output.append(nextHop); + output.append("\n"); + output.append("\tpathCost: "); + output.append(pathCost); + output.append("\n"); + output.append("\tLQIIn: "); + output.append(LQIIn); + output.append("\n"); + output.append("\tLQIOut: "); + output.append(LQIOut); + output.append("\n"); + output.append("\tage: "); + output.append(age); + output.append("\n"); + output.append("\tallocated: "); + output.append(allocated); + output.append("\n"); + output.append("\tlinkEstablished: "); + output.append(linkEstablished); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class ThreadNetworkDiagnosticsClusterSecurityPolicy { + public Integer rotationTime; + public Integer flags; + + public ThreadNetworkDiagnosticsClusterSecurityPolicy(Integer rotationTime, Integer flags) { + this.rotationTime = rotationTime; + this.flags = flags; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("ThreadNetworkDiagnosticsClusterSecurityPolicy {\n"); + output.append("\trotationTime: "); + output.append(rotationTime); + output.append("\n"); + output.append("\tflags: "); + output.append(flags); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } + } + + public static class UserLabelClusterLabelStruct { + public String label; + public String value; + + public UserLabelClusterLabelStruct(String label, String value) { + this.label = label; + this.value = value; + } + + @Override + public String toString() { + StringBuilder output = new StringBuilder(); + output.append("UserLabelClusterLabelStruct {\n"); + output.append("\tlabel: "); + output.append(label); + output.append("\n"); + output.append("\tvalue: "); + output.append(value); + output.append("\n"); + output.append("}\n"); + return output.toString(); + } } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterTarget {\n"); - output.append("\tcluster: "); - output.append(cluster); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("\tdeviceType: "); - output.append(deviceType); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class AccessControlClusterAccessControlEntry { -public Integer fabricIndex; -public Integer privilege; -public Integer authMode; -public @Nullable ArrayList subjects; -public @Nullable ArrayList targets; - - public AccessControlClusterAccessControlEntry( - Integer fabricIndex - , Integer privilege - , Integer authMode - , @Nullable ArrayList subjects - , @Nullable ArrayList targets - ) { - this.fabricIndex = fabricIndex; - this.privilege = privilege; - this.authMode = authMode; - this.subjects = subjects; - this.targets = targets; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterAccessControlEntry {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tprivilege: "); - output.append(privilege); - output.append("\n"); - output.append("\tauthMode: "); - output.append(authMode); - output.append("\n"); - output.append("\tsubjects: "); - output.append(subjects); - output.append("\n"); - output.append("\ttargets: "); - output.append(targets); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class AccessControlClusterExtensionEntry { -public Integer fabricIndex; -public byte[] data; - - public AccessControlClusterExtensionEntry( - Integer fabricIndex - , byte[] data - ) { - this.fabricIndex = fabricIndex; - this.data = data; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AccessControlClusterExtensionEntry {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tdata: "); - output.append(Arrays.toString(data)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ApplicationBasicClusterApplicationBasicApplication { -public Integer catalogVendorId; -public String applicationId; - - public ApplicationBasicClusterApplicationBasicApplication( - Integer catalogVendorId - , String applicationId - ) { - this.catalogVendorId = catalogVendorId; - this.applicationId = applicationId; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationBasicClusterApplicationBasicApplication {\n"); - output.append("\tcatalogVendorId: "); - output.append(catalogVendorId); - output.append("\n"); - output.append("\tapplicationId: "); - output.append(applicationId); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ApplicationLauncherClusterApplicationLauncherApplication { -public Integer catalogVendorId; -public String applicationId; - - public ApplicationLauncherClusterApplicationLauncherApplication( - Integer catalogVendorId - , String applicationId - ) { - this.catalogVendorId = catalogVendorId; - this.applicationId = applicationId; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationLauncherClusterApplicationLauncherApplication {\n"); - output.append("\tcatalogVendorId: "); - output.append(catalogVendorId); - output.append("\n"); - output.append("\tapplicationId: "); - output.append(applicationId); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ApplicationLauncherClusterApplicationEP { -public ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application; -public String endpoint; - - public ApplicationLauncherClusterApplicationEP( - ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication application - , String endpoint - ) { - this.application = application; - this.endpoint = endpoint; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ApplicationLauncherClusterApplicationEP {\n"); - output.append("\tapplication: "); - output.append(application); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class AudioOutputClusterOutputInfo { -public Integer index; -public Integer outputType; -public String name; - - public AudioOutputClusterOutputInfo( - Integer index - , Integer outputType - , String name - ) { - this.index = index; - this.outputType = outputType; - this.name = name; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("AudioOutputClusterOutputInfo {\n"); - output.append("\tindex: "); - output.append(index); - output.append("\n"); - output.append("\toutputType: "); - output.append(outputType); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class BridgedActionsClusterActionStruct { -public Integer actionID; -public String name; -public Integer type; -public Integer endpointListID; -public Integer supportedCommands; -public Integer status; - - public BridgedActionsClusterActionStruct( - Integer actionID - , String name - , Integer type - , Integer endpointListID - , Integer supportedCommands - , Integer status - ) { - this.actionID = actionID; - this.name = name; - this.type = type; - this.endpointListID = endpointListID; - this.supportedCommands = supportedCommands; - this.status = status; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedActionsClusterActionStruct {\n"); - output.append("\tactionID: "); - output.append(actionID); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tendpointListID: "); - output.append(endpointListID); - output.append("\n"); - output.append("\tsupportedCommands: "); - output.append(supportedCommands); - output.append("\n"); - output.append("\tstatus: "); - output.append(status); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class BridgedActionsClusterEndpointListStruct { -public Integer endpointListID; -public String name; -public Integer type; -public ArrayList endpoints; - - public BridgedActionsClusterEndpointListStruct( - Integer endpointListID - , String name - , Integer type - , ArrayList endpoints - ) { - this.endpointListID = endpointListID; - this.name = name; - this.type = type; - this.endpoints = endpoints; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("BridgedActionsClusterEndpointListStruct {\n"); - output.append("\tendpointListID: "); - output.append(endpointListID); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tendpoints: "); - output.append(endpoints); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ChannelClusterChannelInfo { -public Integer majorNumber; -public Integer minorNumber; -public String name; -public String callSign; -public String affiliateCallSign; - - public ChannelClusterChannelInfo( - Integer majorNumber - , Integer minorNumber - , String name - , String callSign - , String affiliateCallSign - ) { - this.majorNumber = majorNumber; - this.minorNumber = minorNumber; - this.name = name; - this.callSign = callSign; - this.affiliateCallSign = affiliateCallSign; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ChannelClusterChannelInfo {\n"); - output.append("\tmajorNumber: "); - output.append(majorNumber); - output.append("\n"); - output.append("\tminorNumber: "); - output.append(minorNumber); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tcallSign: "); - output.append(callSign); - output.append("\n"); - output.append("\taffiliateCallSign: "); - output.append(affiliateCallSign); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ChannelClusterLineupInfo { -public String operatorName; -public String lineupName; -public String postalCode; -public Integer lineupInfoType; - - public ChannelClusterLineupInfo( - String operatorName - , String lineupName - , String postalCode - , Integer lineupInfoType - ) { - this.operatorName = operatorName; - this.lineupName = lineupName; - this.postalCode = postalCode; - this.lineupInfoType = lineupInfoType; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ChannelClusterLineupInfo {\n"); - output.append("\toperatorName: "); - output.append(operatorName); - output.append("\n"); - output.append("\tlineupName: "); - output.append(lineupName); - output.append("\n"); - output.append("\tpostalCode: "); - output.append(postalCode); - output.append("\n"); - output.append("\tlineupInfoType: "); - output.append(lineupInfoType); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterDimension { -public Double width; -public Double height; -public Integer metric; - - public ContentLauncherClusterDimension( - Double width - , Double height - , Integer metric - ) { - this.width = width; - this.height = height; - this.metric = metric; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterDimension {\n"); - output.append("\twidth: "); - output.append(width); - output.append("\n"); - output.append("\theight: "); - output.append(height); - output.append("\n"); - output.append("\tmetric: "); - output.append(metric); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterAdditionalInfo { -public String name; -public String value; - - public ContentLauncherClusterAdditionalInfo( - String name - , String value - ) { - this.name = name; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterAdditionalInfo {\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterParameter { -public Integer type; -public String value; -public ArrayList externalIDList; - - public ContentLauncherClusterParameter( - Integer type - , String value - , ArrayList externalIDList - ) { - this.type = type; - this.value = value; - this.externalIDList = externalIDList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterParameter {\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("\texternalIDList: "); - output.append(externalIDList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterContentSearch { -public ArrayList parameterList; - - public ContentLauncherClusterContentSearch( - ArrayList parameterList - ) { - this.parameterList = parameterList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterContentSearch {\n"); - output.append("\tparameterList: "); - output.append(parameterList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterStyleInformation { -public String imageUrl; -public String color; -public ChipStructs.ContentLauncherClusterDimension size; - - public ContentLauncherClusterStyleInformation( - String imageUrl - , String color - , ChipStructs.ContentLauncherClusterDimension size - ) { - this.imageUrl = imageUrl; - this.color = color; - this.size = size; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterStyleInformation {\n"); - output.append("\timageUrl: "); - output.append(imageUrl); - output.append("\n"); - output.append("\tcolor: "); - output.append(color); - output.append("\n"); - output.append("\tsize: "); - output.append(size); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ContentLauncherClusterBrandingInformation { -public String providerName; -public ChipStructs.ContentLauncherClusterStyleInformation background; -public ChipStructs.ContentLauncherClusterStyleInformation logo; -public ChipStructs.ContentLauncherClusterStyleInformation progressBar; -public ChipStructs.ContentLauncherClusterStyleInformation splash; -public ChipStructs.ContentLauncherClusterStyleInformation waterMark; - - public ContentLauncherClusterBrandingInformation( - String providerName - , ChipStructs.ContentLauncherClusterStyleInformation background - , ChipStructs.ContentLauncherClusterStyleInformation logo - , ChipStructs.ContentLauncherClusterStyleInformation progressBar - , ChipStructs.ContentLauncherClusterStyleInformation splash - , ChipStructs.ContentLauncherClusterStyleInformation waterMark - ) { - this.providerName = providerName; - this.background = background; - this.logo = logo; - this.progressBar = progressBar; - this.splash = splash; - this.waterMark = waterMark; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ContentLauncherClusterBrandingInformation {\n"); - output.append("\tproviderName: "); - output.append(providerName); - output.append("\n"); - output.append("\tbackground: "); - output.append(background); - output.append("\n"); - output.append("\tlogo: "); - output.append(logo); - output.append("\n"); - output.append("\tprogressBar: "); - output.append(progressBar); - output.append("\n"); - output.append("\tsplash: "); - output.append(splash); - output.append("\n"); - output.append("\twaterMark: "); - output.append(waterMark); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class DescriptorClusterDeviceType { -public Long type; -public Integer revision; - - public DescriptorClusterDeviceType( - Long type - , Integer revision - ) { - this.type = type; - this.revision = revision; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DescriptorClusterDeviceType {\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("\trevision: "); - output.append(revision); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class DoorLockClusterDlCredential { -public Integer credentialType; -public Integer credentialIndex; - - public DoorLockClusterDlCredential( - Integer credentialType - , Integer credentialIndex - ) { - this.credentialType = credentialType; - this.credentialIndex = credentialIndex; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("DoorLockClusterDlCredential {\n"); - output.append("\tcredentialType: "); - output.append(credentialType); - output.append("\n"); - output.append("\tcredentialIndex: "); - output.append(credentialIndex); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class FixedLabelClusterLabelStruct { -public String label; -public String value; - - public FixedLabelClusterLabelStruct( - String label - , String value - ) { - this.label = label; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("FixedLabelClusterLabelStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GeneralCommissioningClusterBasicCommissioningInfoType { -public Long failSafeExpiryLengthMs; - - public GeneralCommissioningClusterBasicCommissioningInfoType( - Long failSafeExpiryLengthMs - ) { - this.failSafeExpiryLengthMs = failSafeExpiryLengthMs; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GeneralCommissioningClusterBasicCommissioningInfoType {\n"); - output.append("\tfailSafeExpiryLengthMs: "); - output.append(failSafeExpiryLengthMs); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GeneralDiagnosticsClusterNetworkInterfaceType { -public String name; -public Boolean fabricConnected; -public Boolean offPremiseServicesReachableIPv4; -public Boolean offPremiseServicesReachableIPv6; -public byte[] hardwareAddress; -public Integer type; - - public GeneralDiagnosticsClusterNetworkInterfaceType( - String name - , Boolean fabricConnected - , Boolean offPremiseServicesReachableIPv4 - , Boolean offPremiseServicesReachableIPv6 - , byte[] hardwareAddress - , Integer type - ) { - this.name = name; - this.fabricConnected = fabricConnected; - this.offPremiseServicesReachableIPv4 = offPremiseServicesReachableIPv4; - this.offPremiseServicesReachableIPv6 = offPremiseServicesReachableIPv6; - this.hardwareAddress = hardwareAddress; - this.type = type; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GeneralDiagnosticsClusterNetworkInterfaceType {\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tfabricConnected: "); - output.append(fabricConnected); - output.append("\n"); - output.append("\toffPremiseServicesReachableIPv4: "); - output.append(offPremiseServicesReachableIPv4); - output.append("\n"); - output.append("\toffPremiseServicesReachableIPv6: "); - output.append(offPremiseServicesReachableIPv6); - output.append("\n"); - output.append("\thardwareAddress: "); - output.append(Arrays.toString(hardwareAddress)); - output.append("\n"); - output.append("\ttype: "); - output.append(type); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GroupKeyManagementClusterGroupInfo { -public Integer fabricIndex; -public Integer groupId; -public ArrayList endpoints; -public String groupName; - - public GroupKeyManagementClusterGroupInfo( - Integer fabricIndex - , Integer groupId - , ArrayList endpoints - , String groupName - ) { - this.fabricIndex = fabricIndex; - this.groupId = groupId; - this.endpoints = endpoints; - this.groupName = groupName; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupInfo {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tgroupId: "); - output.append(groupId); - output.append("\n"); - output.append("\tendpoints: "); - output.append(endpoints); - output.append("\n"); - output.append("\tgroupName: "); - output.append(groupName); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GroupKeyManagementClusterGroupKey { -public Integer fabricIndex; -public Integer groupId; -public Integer groupKeySetID; - - public GroupKeyManagementClusterGroupKey( - Integer fabricIndex - , Integer groupId - , Integer groupKeySetID - ) { - this.fabricIndex = fabricIndex; - this.groupId = groupId; - this.groupKeySetID = groupKeySetID; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupKey {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tgroupId: "); - output.append(groupId); - output.append("\n"); - output.append("\tgroupKeySetID: "); - output.append(groupKeySetID); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class GroupKeyManagementClusterGroupKeySet { -public Integer groupKeySetID; -public Integer securityPolicy; -public byte[] epochKey0; -public Long epochStartTime0; -public byte[] epochKey1; -public Long epochStartTime1; -public byte[] epochKey2; -public Long epochStartTime2; - - public GroupKeyManagementClusterGroupKeySet( - Integer groupKeySetID - , Integer securityPolicy - , byte[] epochKey0 - , Long epochStartTime0 - , byte[] epochKey1 - , Long epochStartTime1 - , byte[] epochKey2 - , Long epochStartTime2 - ) { - this.groupKeySetID = groupKeySetID; - this.securityPolicy = securityPolicy; - this.epochKey0 = epochKey0; - this.epochStartTime0 = epochStartTime0; - this.epochKey1 = epochKey1; - this.epochStartTime1 = epochStartTime1; - this.epochKey2 = epochKey2; - this.epochStartTime2 = epochStartTime2; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("GroupKeyManagementClusterGroupKeySet {\n"); - output.append("\tgroupKeySetID: "); - output.append(groupKeySetID); - output.append("\n"); - output.append("\tsecurityPolicy: "); - output.append(securityPolicy); - output.append("\n"); - output.append("\tepochKey0: "); - output.append(Arrays.toString(epochKey0)); - output.append("\n"); - output.append("\tepochStartTime0: "); - output.append(epochStartTime0); - output.append("\n"); - output.append("\tepochKey1: "); - output.append(Arrays.toString(epochKey1)); - output.append("\n"); - output.append("\tepochStartTime1: "); - output.append(epochStartTime1); - output.append("\n"); - output.append("\tepochKey2: "); - output.append(Arrays.toString(epochKey2)); - output.append("\n"); - output.append("\tepochStartTime2: "); - output.append(epochStartTime2); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class MediaInputClusterInputInfo { -public Integer index; -public Integer inputType; -public String name; -public String description; - - public MediaInputClusterInputInfo( - Integer index - , Integer inputType - , String name - , String description - ) { - this.index = index; - this.inputType = inputType; - this.name = name; - this.description = description; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("MediaInputClusterInputInfo {\n"); - output.append("\tindex: "); - output.append(index); - output.append("\n"); - output.append("\tinputType: "); - output.append(inputType); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tdescription: "); - output.append(description); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class MediaPlaybackClusterPlaybackPosition { -public Long updatedAt; -public Long position; - - public MediaPlaybackClusterPlaybackPosition( - Long updatedAt - , Long position - ) { - this.updatedAt = updatedAt; - this.position = position; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("MediaPlaybackClusterPlaybackPosition {\n"); - output.append("\tupdatedAt: "); - output.append(updatedAt); - output.append("\n"); - output.append("\tposition: "); - output.append(position); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ModeSelectClusterModeOptionStruct { -public String label; -public Integer mode; -public Long semanticTag; - - public ModeSelectClusterModeOptionStruct( - String label - , Integer mode - , Long semanticTag - ) { - this.label = label; - this.mode = mode; - this.semanticTag = semanticTag; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ModeSelectClusterModeOptionStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tmode: "); - output.append(mode); - output.append("\n"); - output.append("\tsemanticTag: "); - output.append(semanticTag); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ModeSelectClusterSemanticTag { -public Integer mfgCode; -public Integer value; - - public ModeSelectClusterSemanticTag( - Integer mfgCode - , Integer value - ) { - this.mfgCode = mfgCode; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ModeSelectClusterSemanticTag {\n"); - output.append("\tmfgCode: "); - output.append(mfgCode); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class NetworkCommissioningClusterNetworkInfo { -public byte[] networkID; -public Boolean connected; - - public NetworkCommissioningClusterNetworkInfo( - byte[] networkID - , Boolean connected - ) { - this.networkID = networkID; - this.connected = connected; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterNetworkInfo {\n"); - output.append("\tnetworkID: "); - output.append(Arrays.toString(networkID)); - output.append("\n"); - output.append("\tconnected: "); - output.append(connected); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class NetworkCommissioningClusterThreadInterfaceScanResult { -public Long panId; -public Long extendedPanId; -public String networkName; -public Integer channel; -public Integer version; -public Long extendedAddress; -public Integer rssi; -public Integer lqi; - - public NetworkCommissioningClusterThreadInterfaceScanResult( - Long panId - , Long extendedPanId - , String networkName - , Integer channel - , Integer version - , Long extendedAddress - , Integer rssi - , Integer lqi - ) { - this.panId = panId; - this.extendedPanId = extendedPanId; - this.networkName = networkName; - this.channel = channel; - this.version = version; - this.extendedAddress = extendedAddress; - this.rssi = rssi; - this.lqi = lqi; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterThreadInterfaceScanResult {\n"); - output.append("\tpanId: "); - output.append(panId); - output.append("\n"); - output.append("\textendedPanId: "); - output.append(extendedPanId); - output.append("\n"); - output.append("\tnetworkName: "); - output.append(networkName); - output.append("\n"); - output.append("\tchannel: "); - output.append(channel); - output.append("\n"); - output.append("\tversion: "); - output.append(version); - output.append("\n"); - output.append("\textendedAddress: "); - output.append(extendedAddress); - output.append("\n"); - output.append("\trssi: "); - output.append(rssi); - output.append("\n"); - output.append("\tlqi: "); - output.append(lqi); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class NetworkCommissioningClusterWiFiInterfaceScanResult { -public Integer security; -public byte[] ssid; -public byte[] bssid; -public Integer channel; -public Integer wiFiBand; -public Integer rssi; - - public NetworkCommissioningClusterWiFiInterfaceScanResult( - Integer security - , byte[] ssid - , byte[] bssid - , Integer channel - , Integer wiFiBand - , Integer rssi - ) { - this.security = security; - this.ssid = ssid; - this.bssid = bssid; - this.channel = channel; - this.wiFiBand = wiFiBand; - this.rssi = rssi; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("NetworkCommissioningClusterWiFiInterfaceScanResult {\n"); - output.append("\tsecurity: "); - output.append(security); - output.append("\n"); - output.append("\tssid: "); - output.append(Arrays.toString(ssid)); - output.append("\n"); - output.append("\tbssid: "); - output.append(Arrays.toString(bssid)); - output.append("\n"); - output.append("\tchannel: "); - output.append(channel); - output.append("\n"); - output.append("\twiFiBand: "); - output.append(wiFiBand); - output.append("\n"); - output.append("\trssi: "); - output.append(rssi); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class OtaSoftwareUpdateRequestorClusterProviderLocation { -public Integer fabricIndex; -public Long providerNodeID; -public Integer endpoint; - - public OtaSoftwareUpdateRequestorClusterProviderLocation( - Integer fabricIndex - , Long providerNodeID - , Integer endpoint - ) { - this.fabricIndex = fabricIndex; - this.providerNodeID = providerNodeID; - this.endpoint = endpoint; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OtaSoftwareUpdateRequestorClusterProviderLocation {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tproviderNodeID: "); - output.append(providerNodeID); - output.append("\n"); - output.append("\tendpoint: "); - output.append(endpoint); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class OperationalCredentialsClusterFabricDescriptor { -public Integer fabricIndex; -public byte[] rootPublicKey; -public Integer vendorId; -public Long fabricId; -public Long nodeId; -public String label; - - public OperationalCredentialsClusterFabricDescriptor( - Integer fabricIndex - , byte[] rootPublicKey - , Integer vendorId - , Long fabricId - , Long nodeId - , String label - ) { - this.fabricIndex = fabricIndex; - this.rootPublicKey = rootPublicKey; - this.vendorId = vendorId; - this.fabricId = fabricId; - this.nodeId = nodeId; - this.label = label; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OperationalCredentialsClusterFabricDescriptor {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\trootPublicKey: "); - output.append(Arrays.toString(rootPublicKey)); - output.append("\n"); - output.append("\tvendorId: "); - output.append(vendorId); - output.append("\n"); - output.append("\tfabricId: "); - output.append(fabricId); - output.append("\n"); - output.append("\tnodeId: "); - output.append(nodeId); - output.append("\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class OperationalCredentialsClusterNOCStruct { -public Integer fabricIndex; -public byte[] noc; -public @Nullable byte[] icac; - - public OperationalCredentialsClusterNOCStruct( - Integer fabricIndex - , byte[] noc - , @Nullable byte[] icac - ) { - this.fabricIndex = fabricIndex; - this.noc = noc; - this.icac = icac; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("OperationalCredentialsClusterNOCStruct {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\tnoc: "); - output.append(Arrays.toString(noc)); - output.append("\n"); - output.append("\ticac: "); - output.append(Arrays.toString(icac)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class PowerSourceClusterBatChargeFaultChangeType { -public ArrayList current; -public ArrayList previous; - - public PowerSourceClusterBatChargeFaultChangeType( - ArrayList current - , ArrayList previous - ) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterBatChargeFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class PowerSourceClusterBatFaultChangeType { -public ArrayList current; -public ArrayList previous; - - public PowerSourceClusterBatFaultChangeType( - ArrayList current - , ArrayList previous - ) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterBatFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class PowerSourceClusterWiredFaultChangeType { -public ArrayList current; -public ArrayList previous; - - public PowerSourceClusterWiredFaultChangeType( - ArrayList current - , ArrayList previous - ) { - this.current = current; - this.previous = previous; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("PowerSourceClusterWiredFaultChangeType {\n"); - output.append("\tcurrent: "); - output.append(current); - output.append("\n"); - output.append("\tprevious: "); - output.append(previous); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ScenesClusterSceneExtensionFieldSet { -public Long clusterId; -public Integer length; -public Integer value; - - public ScenesClusterSceneExtensionFieldSet( - Long clusterId - , Integer length - , Integer value - ) { - this.clusterId = clusterId; - this.length = length; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ScenesClusterSceneExtensionFieldSet {\n"); - output.append("\tclusterId: "); - output.append(clusterId); - output.append("\n"); - output.append("\tlength: "); - output.append(length); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class SoftwareDiagnosticsClusterSoftwareFaultStruct { -public Long id; -public String name; -public byte[] faultRecording; - - public SoftwareDiagnosticsClusterSoftwareFaultStruct( - Long id - , String name - , byte[] faultRecording - ) { - this.id = id; - this.name = name; - this.faultRecording = faultRecording; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SoftwareDiagnosticsClusterSoftwareFaultStruct {\n"); - output.append("\tid: "); - output.append(id); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tfaultRecording: "); - output.append(Arrays.toString(faultRecording)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class SoftwareDiagnosticsClusterThreadMetrics { -public Long id; -public String name; -public Long stackFreeCurrent; -public Long stackFreeMinimum; -public Long stackSize; - - public SoftwareDiagnosticsClusterThreadMetrics( - Long id - , String name - , Long stackFreeCurrent - , Long stackFreeMinimum - , Long stackSize - ) { - this.id = id; - this.name = name; - this.stackFreeCurrent = stackFreeCurrent; - this.stackFreeMinimum = stackFreeMinimum; - this.stackSize = stackSize; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("SoftwareDiagnosticsClusterThreadMetrics {\n"); - output.append("\tid: "); - output.append(id); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("\tstackFreeCurrent: "); - output.append(stackFreeCurrent); - output.append("\n"); - output.append("\tstackFreeMinimum: "); - output.append(stackFreeMinimum); - output.append("\n"); - output.append("\tstackSize: "); - output.append(stackSize); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TargetNavigatorClusterTargetInfo { -public Integer identifier; -public String name; - - public TargetNavigatorClusterTargetInfo( - Integer identifier - , String name - ) { - this.identifier = identifier; - this.name = name; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TargetNavigatorClusterTargetInfo {\n"); - output.append("\tidentifier: "); - output.append(identifier); - output.append("\n"); - output.append("\tname: "); - output.append(name); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterSimpleStruct { -public Integer a; -public Boolean b; -public Integer c; -public byte[] d; -public String e; -public Integer f; -public Float g; -public Double h; - - public TestClusterClusterSimpleStruct( - Integer a - , Boolean b - , Integer c - , byte[] d - , String e - , Integer f - , Float g - , Double h - ) { - this.a = a; - this.b = b; - this.c = c; - this.d = d; - this.e = e; - this.f = f; - this.g = g; - this.h = h; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterSimpleStruct {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("\td: "); - output.append(Arrays.toString(d)); - output.append("\n"); - output.append("\te: "); - output.append(e); - output.append("\n"); - output.append("\tf: "); - output.append(f); - output.append("\n"); - output.append("\tg: "); - output.append(g); - output.append("\n"); - output.append("\th: "); - output.append(h); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterNullablesAndOptionalsStruct { -public @Nullable Integer nullableInt; -public Optional optionalInt; -public @Nullable Optional nullableOptionalInt; -public @Nullable String nullableString; -public Optional optionalString; -public @Nullable Optional nullableOptionalString; -public @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct; -public Optional optionalStruct; -public @Nullable Optional nullableOptionalStruct; -public @Nullable ArrayList nullableList; -public Optional> optionalList; -public @Nullable Optional> nullableOptionalList; - - public TestClusterClusterNullablesAndOptionalsStruct( - @Nullable Integer nullableInt - , Optional optionalInt - , @Nullable Optional nullableOptionalInt - , @Nullable String nullableString - , Optional optionalString - , @Nullable Optional nullableOptionalString - , @Nullable ChipStructs.TestClusterClusterSimpleStruct nullableStruct - , Optional optionalStruct - , @Nullable Optional nullableOptionalStruct - , @Nullable ArrayList nullableList - , Optional> optionalList - , @Nullable Optional> nullableOptionalList - ) { - this.nullableInt = nullableInt; - this.optionalInt = optionalInt; - this.nullableOptionalInt = nullableOptionalInt; - this.nullableString = nullableString; - this.optionalString = optionalString; - this.nullableOptionalString = nullableOptionalString; - this.nullableStruct = nullableStruct; - this.optionalStruct = optionalStruct; - this.nullableOptionalStruct = nullableOptionalStruct; - this.nullableList = nullableList; - this.optionalList = optionalList; - this.nullableOptionalList = nullableOptionalList; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNullablesAndOptionalsStruct {\n"); - output.append("\tnullableInt: "); - output.append(nullableInt); - output.append("\n"); - output.append("\toptionalInt: "); - output.append(optionalInt); - output.append("\n"); - output.append("\tnullableOptionalInt: "); - output.append(nullableOptionalInt); - output.append("\n"); - output.append("\tnullableString: "); - output.append(nullableString); - output.append("\n"); - output.append("\toptionalString: "); - output.append(optionalString); - output.append("\n"); - output.append("\tnullableOptionalString: "); - output.append(nullableOptionalString); - output.append("\n"); - output.append("\tnullableStruct: "); - output.append(nullableStruct); - output.append("\n"); - output.append("\toptionalStruct: "); - output.append(optionalStruct); - output.append("\n"); - output.append("\tnullableOptionalStruct: "); - output.append(nullableOptionalStruct); - output.append("\n"); - output.append("\tnullableList: "); - output.append(nullableList); - output.append("\n"); - output.append("\toptionalList: "); - output.append(optionalList); - output.append("\n"); - output.append("\tnullableOptionalList: "); - output.append(nullableOptionalList); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterNestedStruct { -public Integer a; -public Boolean b; -public ChipStructs.TestClusterClusterSimpleStruct c; - - public TestClusterClusterNestedStruct( - Integer a - , Boolean b - , ChipStructs.TestClusterClusterSimpleStruct c - ) { - this.a = a; - this.b = b; - this.c = c; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNestedStruct {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterNestedStructList { -public Integer a; -public Boolean b; -public ChipStructs.TestClusterClusterSimpleStruct c; -public ArrayList d; -public ArrayList e; -public ArrayList f; -public ArrayList g; - - public TestClusterClusterNestedStructList( - Integer a - , Boolean b - , ChipStructs.TestClusterClusterSimpleStruct c - , ArrayList d - , ArrayList e - , ArrayList f - , ArrayList g - ) { - this.a = a; - this.b = b; - this.c = c; - this.d = d; - this.e = e; - this.f = f; - this.g = g; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterNestedStructList {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("\tb: "); - output.append(b); - output.append("\n"); - output.append("\tc: "); - output.append(c); - output.append("\n"); - output.append("\td: "); - output.append(d); - output.append("\n"); - output.append("\te: "); - output.append(e); - output.append("\n"); - output.append("\tf: "); - output.append(f); - output.append("\n"); - output.append("\tg: "); - output.append(g); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterDoubleNestedStructList { -public ArrayList a; - - public TestClusterClusterDoubleNestedStructList( - ArrayList a - ) { - this.a = a; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterDoubleNestedStructList {\n"); - output.append("\ta: "); - output.append(a); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterTestFabricScoped { -public Integer fabricIndex; - - public TestClusterClusterTestFabricScoped( - Integer fabricIndex - ) { - this.fabricIndex = fabricIndex; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterTestFabricScoped {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class TestClusterClusterTestListStructOctet { -public Long fabricIndex; -public byte[] operationalCert; - - public TestClusterClusterTestListStructOctet( - Long fabricIndex - , byte[] operationalCert - ) { - this.fabricIndex = fabricIndex; - this.operationalCert = operationalCert; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("TestClusterClusterTestListStructOctet {\n"); - output.append("\tfabricIndex: "); - output.append(fabricIndex); - output.append("\n"); - output.append("\toperationalCert: "); - output.append(Arrays.toString(operationalCert)); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterNeighborTable { -public Long extAddress; -public Long age; -public Integer rloc16; -public Long linkFrameCounter; -public Long mleFrameCounter; -public Integer lqi; -public Integer averageRssi; -public Integer lastRssi; -public Integer frameErrorRate; -public Integer messageErrorRate; -public Boolean rxOnWhenIdle; -public Boolean fullThreadDevice; -public Boolean fullNetworkData; -public Boolean isChild; - - public ThreadNetworkDiagnosticsClusterNeighborTable( - Long extAddress - , Long age - , Integer rloc16 - , Long linkFrameCounter - , Long mleFrameCounter - , Integer lqi - , Integer averageRssi - , Integer lastRssi - , Integer frameErrorRate - , Integer messageErrorRate - , Boolean rxOnWhenIdle - , Boolean fullThreadDevice - , Boolean fullNetworkData - , Boolean isChild - ) { - this.extAddress = extAddress; - this.age = age; - this.rloc16 = rloc16; - this.linkFrameCounter = linkFrameCounter; - this.mleFrameCounter = mleFrameCounter; - this.lqi = lqi; - this.averageRssi = averageRssi; - this.lastRssi = lastRssi; - this.frameErrorRate = frameErrorRate; - this.messageErrorRate = messageErrorRate; - this.rxOnWhenIdle = rxOnWhenIdle; - this.fullThreadDevice = fullThreadDevice; - this.fullNetworkData = fullNetworkData; - this.isChild = isChild; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterNeighborTable {\n"); - output.append("\textAddress: "); - output.append(extAddress); - output.append("\n"); - output.append("\tage: "); - output.append(age); - output.append("\n"); - output.append("\trloc16: "); - output.append(rloc16); - output.append("\n"); - output.append("\tlinkFrameCounter: "); - output.append(linkFrameCounter); - output.append("\n"); - output.append("\tmleFrameCounter: "); - output.append(mleFrameCounter); - output.append("\n"); - output.append("\tlqi: "); - output.append(lqi); - output.append("\n"); - output.append("\taverageRssi: "); - output.append(averageRssi); - output.append("\n"); - output.append("\tlastRssi: "); - output.append(lastRssi); - output.append("\n"); - output.append("\tframeErrorRate: "); - output.append(frameErrorRate); - output.append("\n"); - output.append("\tmessageErrorRate: "); - output.append(messageErrorRate); - output.append("\n"); - output.append("\trxOnWhenIdle: "); - output.append(rxOnWhenIdle); - output.append("\n"); - output.append("\tfullThreadDevice: "); - output.append(fullThreadDevice); - output.append("\n"); - output.append("\tfullNetworkData: "); - output.append(fullNetworkData); - output.append("\n"); - output.append("\tisChild: "); - output.append(isChild); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterOperationalDatasetComponents { -public Boolean activeTimestampPresent; -public Boolean pendingTimestampPresent; -public Boolean masterKeyPresent; -public Boolean networkNamePresent; -public Boolean extendedPanIdPresent; -public Boolean meshLocalPrefixPresent; -public Boolean delayPresent; -public Boolean panIdPresent; -public Boolean channelPresent; -public Boolean pskcPresent; -public Boolean securityPolicyPresent; -public Boolean channelMaskPresent; - - public ThreadNetworkDiagnosticsClusterOperationalDatasetComponents( - Boolean activeTimestampPresent - , Boolean pendingTimestampPresent - , Boolean masterKeyPresent - , Boolean networkNamePresent - , Boolean extendedPanIdPresent - , Boolean meshLocalPrefixPresent - , Boolean delayPresent - , Boolean panIdPresent - , Boolean channelPresent - , Boolean pskcPresent - , Boolean securityPolicyPresent - , Boolean channelMaskPresent - ) { - this.activeTimestampPresent = activeTimestampPresent; - this.pendingTimestampPresent = pendingTimestampPresent; - this.masterKeyPresent = masterKeyPresent; - this.networkNamePresent = networkNamePresent; - this.extendedPanIdPresent = extendedPanIdPresent; - this.meshLocalPrefixPresent = meshLocalPrefixPresent; - this.delayPresent = delayPresent; - this.panIdPresent = panIdPresent; - this.channelPresent = channelPresent; - this.pskcPresent = pskcPresent; - this.securityPolicyPresent = securityPolicyPresent; - this.channelMaskPresent = channelMaskPresent; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterOperationalDatasetComponents {\n"); - output.append("\tactiveTimestampPresent: "); - output.append(activeTimestampPresent); - output.append("\n"); - output.append("\tpendingTimestampPresent: "); - output.append(pendingTimestampPresent); - output.append("\n"); - output.append("\tmasterKeyPresent: "); - output.append(masterKeyPresent); - output.append("\n"); - output.append("\tnetworkNamePresent: "); - output.append(networkNamePresent); - output.append("\n"); - output.append("\textendedPanIdPresent: "); - output.append(extendedPanIdPresent); - output.append("\n"); - output.append("\tmeshLocalPrefixPresent: "); - output.append(meshLocalPrefixPresent); - output.append("\n"); - output.append("\tdelayPresent: "); - output.append(delayPresent); - output.append("\n"); - output.append("\tpanIdPresent: "); - output.append(panIdPresent); - output.append("\n"); - output.append("\tchannelPresent: "); - output.append(channelPresent); - output.append("\n"); - output.append("\tpskcPresent: "); - output.append(pskcPresent); - output.append("\n"); - output.append("\tsecurityPolicyPresent: "); - output.append(securityPolicyPresent); - output.append("\n"); - output.append("\tchannelMaskPresent: "); - output.append(channelMaskPresent); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterRouteTable { -public Long extAddress; -public Integer rloc16; -public Integer routerId; -public Integer nextHop; -public Integer pathCost; -public Integer LQIIn; -public Integer LQIOut; -public Integer age; -public Boolean allocated; -public Boolean linkEstablished; - - public ThreadNetworkDiagnosticsClusterRouteTable( - Long extAddress - , Integer rloc16 - , Integer routerId - , Integer nextHop - , Integer pathCost - , Integer LQIIn - , Integer LQIOut - , Integer age - , Boolean allocated - , Boolean linkEstablished - ) { - this.extAddress = extAddress; - this.rloc16 = rloc16; - this.routerId = routerId; - this.nextHop = nextHop; - this.pathCost = pathCost; - this.LQIIn = LQIIn; - this.LQIOut = LQIOut; - this.age = age; - this.allocated = allocated; - this.linkEstablished = linkEstablished; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterRouteTable {\n"); - output.append("\textAddress: "); - output.append(extAddress); - output.append("\n"); - output.append("\trloc16: "); - output.append(rloc16); - output.append("\n"); - output.append("\trouterId: "); - output.append(routerId); - output.append("\n"); - output.append("\tnextHop: "); - output.append(nextHop); - output.append("\n"); - output.append("\tpathCost: "); - output.append(pathCost); - output.append("\n"); - output.append("\tLQIIn: "); - output.append(LQIIn); - output.append("\n"); - output.append("\tLQIOut: "); - output.append(LQIOut); - output.append("\n"); - output.append("\tage: "); - output.append(age); - output.append("\n"); - output.append("\tallocated: "); - output.append(allocated); - output.append("\n"); - output.append("\tlinkEstablished: "); - output.append(linkEstablished); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class ThreadNetworkDiagnosticsClusterSecurityPolicy { -public Integer rotationTime; -public Integer flags; - - public ThreadNetworkDiagnosticsClusterSecurityPolicy( - Integer rotationTime - , Integer flags - ) { - this.rotationTime = rotationTime; - this.flags = flags; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("ThreadNetworkDiagnosticsClusterSecurityPolicy {\n"); - output.append("\trotationTime: "); - output.append(rotationTime); - output.append("\n"); - output.append("\tflags: "); - output.append(flags); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - -public static class UserLabelClusterLabelStruct { -public String label; -public String value; - - public UserLabelClusterLabelStruct( - String label - , String value - ) { - this.label = label; - this.value = value; - } - - @Override - public String toString() { - StringBuilder output = new StringBuilder(); - output.append("UserLabelClusterLabelStruct {\n"); - output.append("\tlabel: "); - output.append(label); - output.append("\n"); - output.append("\tvalue: "); - output.append(value); - output.append("\n"); - output.append("}\n"); - return output.toString(); - } -} - } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index 36b3755afb50ea..8bead24d836255 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -20,26 +20,24 @@ package chip.devicecontroller; import androidx.annotation.Nullable; +import chip.clusterinfo.ClusterCommandCallback; +import chip.clusterinfo.ClusterInfo; +import chip.clusterinfo.CommandParameterInfo; +import chip.clusterinfo.CommandResponseInfo; +import chip.clusterinfo.DelegatedClusterCallback; +import chip.clusterinfo.InteractionInfo; +import chip.devicecontroller.ChipClusters.DefaultClusterCallback; import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Optional; -import androidx.annotation.Nullable; -import chip.clusterinfo.ClusterInfo; -import chip.clusterinfo.InteractionInfo; -import chip.clusterinfo.CommandParameterInfo; -import chip.clusterinfo.DelegatedClusterCallback; -import chip.clusterinfo.ClusterCommandCallback; -import chip.clusterinfo.CommandResponseInfo; -import chip.devicecontroller.ChipClusters.DefaultClusterCallback; -import chip.devicecontroller.ClusterReadMapping; -import chip.devicecontroller.ClusterWriteMapping; public class ClusterInfoMapping { - public static class DelegatedCharStringAttributeCallback implements ChipClusters.CharStringAttributeCallback, DelegatedClusterCallback { + public static class DelegatedCharStringAttributeCallback + implements ChipClusters.CharStringAttributeCallback, DelegatedClusterCallback { /** Indicates a successful read for a CHAR_STRING attribute. */ private ClusterCommandCallback callback; @@ -62,7 +60,8 @@ public void onError(Exception error) { } } - public static class DelegatedOctetStringAttributeCallback implements ChipClusters.OctetStringAttributeCallback, DelegatedClusterCallback { + public static class DelegatedOctetStringAttributeCallback + implements ChipClusters.OctetStringAttributeCallback, DelegatedClusterCallback { /** Indicates a successful read for an OCTET_STRING attribute. */ private ClusterCommandCallback callback; @@ -85,7 +84,8 @@ public void onError(Exception error) { } } - public static class DelegatedIntegerAttributeCallback implements ChipClusters.IntegerAttributeCallback, DelegatedClusterCallback { + public static class DelegatedIntegerAttributeCallback + implements ChipClusters.IntegerAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -107,7 +107,8 @@ public void onError(Exception error) { } } - public static class DelegatedLongAttributeCallback implements ChipClusters.LongAttributeCallback, DelegatedClusterCallback { + public static class DelegatedLongAttributeCallback + implements ChipClusters.LongAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -129,7 +130,8 @@ public void onError(Exception error) { } } - public static class DelegatedBooleanAttributeCallback implements ChipClusters.BooleanAttributeCallback, DelegatedClusterCallback { + public static class DelegatedBooleanAttributeCallback + implements ChipClusters.BooleanAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -151,7 +153,8 @@ public void onError(Exception error) { } } - public static class DelegatedFloatAttributeCallback implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { + public static class DelegatedFloatAttributeCallback + implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -173,7 +176,8 @@ public void onError(Exception error) { } } - public static class DelegatedDoubleAttributeCallback implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { + public static class DelegatedDoubleAttributeCallback + implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -195,7 +199,8 @@ public void onError(Exception error) { } } - public static class DelegatedDefaultClusterCallback implements DefaultClusterCallback, DelegatedClusterCallback { + public static class DelegatedDefaultClusterCallback + implements DefaultClusterCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; @Override @@ -203,7 +208,8 @@ public void setCallbackDelegate(ClusterCommandCallback callback) { this.callback = callback; } - // Parameters and list-adds here should be generated - refer to the template code that creates each callback interface. + // Parameters and list-adds here should be generated - refer to the template code that creates + // each callback interface. @Override public void onSuccess() { Map responseValues = new LinkedHashMap<>(); @@ -216,7544 +222,8880 @@ public void onError(Exception e) { } } + public static class DelegatedAccessControlClusterAclAttributeCallback + implements ChipClusters.AccessControlCluster.AclAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; - public static class DelegatedAccessControlClusterAclAttributeCallback implements ChipClusters.AccessControlCluster.AclAttributeCallback, 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 DelegatedAccessControlClusterExtensionAttributeCallback implements ChipClusters.AccessControlCluster.ExtensionAttributeCallback, 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 DelegatedAccessControlClusterAttributeListAttributeCallback implements ChipClusters.AccessControlCluster.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 DelegatedGetSetupPINResponseCallback implements ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(String setupPIN) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("setupPIN", "String"); - responseValues.put(setupPINResponseValue, setupPIN); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedAccountLoginClusterAttributeListAttributeCallback implements ChipClusters.AccountLoginCluster.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 DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback implements ChipClusters.AdministratorCommissioningCluster.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 DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback implements ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback, 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 DelegatedApplicationBasicClusterAttributeListAttributeCallback implements ChipClusters.ApplicationBasicCluster.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 DelegatedLauncherResponseCallback implements ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback implements ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback, 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 DelegatedApplicationLauncherClusterAttributeListAttributeCallback implements ChipClusters.ApplicationLauncherCluster.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 DelegatedAudioOutputClusterAudioOutputListAttributeCallback implements ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback, 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 DelegatedAudioOutputClusterAttributeListAttributeCallback implements ChipClusters.AudioOutputCluster.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 DelegatedBarrierControlClusterAttributeListAttributeCallback implements ChipClusters.BarrierControlCluster.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 DelegatedBasicClusterAttributeListAttributeCallback implements ChipClusters.BasicCluster.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 DelegatedBinaryInputBasicClusterAttributeListAttributeCallback implements ChipClusters.BinaryInputBasicCluster.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 DelegatedBindingClusterAttributeListAttributeCallback implements ChipClusters.BindingCluster.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 DelegatedBooleanStateClusterAttributeListAttributeCallback implements ChipClusters.BooleanStateCluster.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 DelegatedBridgedActionsClusterActionListAttributeCallback implements ChipClusters.BridgedActionsCluster.ActionListAttributeCallback, 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 DelegatedBridgedActionsClusterEndpointListAttributeCallback implements ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback, 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 DelegatedBridgedActionsClusterAttributeListAttributeCallback implements ChipClusters.BridgedActionsCluster.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 DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback implements ChipClusters.BridgedDeviceBasicCluster.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 DelegatedChangeChannelResponseCallback implements ChipClusters.ChannelCluster.ChangeChannelResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType) { - Map responseValues = new LinkedHashMap<>(); - // channelMatch: Struct ChannelInfo - // Conversion from this type to Java is not properly implemented yet - CommandResponseInfo errorTypeResponseValue = new CommandResponseInfo("errorType", "Integer"); - responseValues.put(errorTypeResponseValue, errorType); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedChannelClusterChannelListAttributeCallback implements ChipClusters.ChannelCluster.ChannelListAttributeCallback, 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 DelegatedChannelClusterAttributeListAttributeCallback implements ChipClusters.ChannelCluster.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 DelegatedColorControlClusterAttributeListAttributeCallback implements ChipClusters.ColorControlCluster.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 DelegatedLaunchResponseCallback implements ChipClusters.ContentLauncherCluster.LaunchResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback implements ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback, 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 DelegatedContentLauncherClusterAttributeListAttributeCallback implements ChipClusters.ContentLauncherCluster.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 DelegatedDescriptorClusterDeviceListAttributeCallback implements ChipClusters.DescriptorCluster.DeviceListAttributeCallback, 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 DelegatedDescriptorClusterServerListAttributeCallback implements ChipClusters.DescriptorCluster.ServerListAttributeCallback, 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 DelegatedDescriptorClusterClientListAttributeCallback implements ChipClusters.DescriptorCluster.ClientListAttributeCallback, 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 DelegatedDescriptorClusterPartsListAttributeCallback implements ChipClusters.DescriptorCluster.PartsListAttributeCallback, 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 DelegatedDescriptorClusterAttributeListAttributeCallback implements ChipClusters.DescriptorCluster.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 DelegatedRetrieveLogsResponseCallback implements ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo contentResponseValue = new CommandResponseInfo("content", "byte[]"); - responseValues.put(contentResponseValue, content); - CommandResponseInfo timeStampResponseValue = new CommandResponseInfo("timeStamp", "Long"); - responseValues.put(timeStampResponseValue, timeStamp); - CommandResponseInfo timeSinceBootResponseValue = new CommandResponseInfo("timeSinceBoot", "Long"); - responseValues.put(timeSinceBootResponseValue, timeSinceBoot); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedDiagnosticLogsClusterAttributeListAttributeCallback implements ChipClusters.DiagnosticLogsCluster.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 DelegatedGetCredentialStatusResponseCallback implements ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Boolean credentialExists, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo credentialExistsResponseValue = new CommandResponseInfo("credentialExists", "Boolean"); - responseValues.put(credentialExistsResponseValue, credentialExists); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo nextCredentialIndexResponseValue = new CommandResponseInfo("nextCredentialIndex", "Integer"); - responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetUserResponseCallback implements ChipClusters.DoorLockCluster.GetUserResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer userIndex, @Nullable String userName, @Nullable Long userUniqueId, @Nullable Integer userStatus, @Nullable Integer userType, @Nullable Integer credentialRule, @Nullable ArrayList credentials, @Nullable Integer creatorFabricIndex, @Nullable Integer lastModifiedFabricIndex, @Nullable Integer nextUserIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo userNameResponseValue = new CommandResponseInfo("userName", "String"); - responseValues.put(userNameResponseValue, userName); - CommandResponseInfo userUniqueIdResponseValue = new CommandResponseInfo("userUniqueId", "Long"); - responseValues.put(userUniqueIdResponseValue, userUniqueId); - CommandResponseInfo userStatusResponseValue = new CommandResponseInfo("userStatus", "Integer"); - responseValues.put(userStatusResponseValue, userStatus); - CommandResponseInfo userTypeResponseValue = new CommandResponseInfo("userType", "Integer"); - responseValues.put(userTypeResponseValue, userType); - CommandResponseInfo credentialRuleResponseValue = new CommandResponseInfo("credentialRule", "Integer"); - responseValues.put(credentialRuleResponseValue, credentialRule); - // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - CommandResponseInfo creatorFabricIndexResponseValue = new CommandResponseInfo("creatorFabricIndex", "Integer"); - responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); - CommandResponseInfo lastModifiedFabricIndexResponseValue = new CommandResponseInfo("lastModifiedFabricIndex", "Integer"); - responseValues.put(lastModifiedFabricIndexResponseValue, lastModifiedFabricIndex); - CommandResponseInfo nextUserIndexResponseValue = new CommandResponseInfo("nextUserIndex", "Integer"); - responseValues.put(nextUserIndexResponseValue, nextUserIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetWeekDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer weekDayIndex, Integer userIndex, Integer status, Optional daysMask, Optional startHour, Optional startMinute, Optional endHour, Optional endMinute) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo weekDayIndexResponseValue = new CommandResponseInfo("weekDayIndex", "Integer"); - responseValues.put(weekDayIndexResponseValue, weekDayIndex); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo daysMaskResponseValue = new CommandResponseInfo("daysMask", "Optional"); - responseValues.put(daysMaskResponseValue, daysMask); - CommandResponseInfo startHourResponseValue = new CommandResponseInfo("startHour", "Optional"); - responseValues.put(startHourResponseValue, startHour); - CommandResponseInfo startMinuteResponseValue = new CommandResponseInfo("startMinute", "Optional"); - responseValues.put(startMinuteResponseValue, startMinute); - CommandResponseInfo endHourResponseValue = new CommandResponseInfo("endHour", "Optional"); - responseValues.put(endHourResponseValue, endHour); - CommandResponseInfo endMinuteResponseValue = new CommandResponseInfo("endMinute", "Optional"); - responseValues.put(endMinuteResponseValue, endMinute); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetYearDayScheduleResponseCallback implements ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer yearDayIndex, Integer userIndex, Integer status, Optional localStartTime, Optional localEndTime) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo yearDayIndexResponseValue = new CommandResponseInfo("yearDayIndex", "Integer"); - responseValues.put(yearDayIndexResponseValue, yearDayIndex); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo localStartTimeResponseValue = new CommandResponseInfo("localStartTime", "Optional"); - responseValues.put(localStartTimeResponseValue, localStartTime); - CommandResponseInfo localEndTimeResponseValue = new CommandResponseInfo("localEndTime", "Optional"); - responseValues.put(localEndTimeResponseValue, localEndTime); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSetCredentialResponseCallback implements ChipClusters.DoorLockCluster.SetCredentialResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); - responseValues.put(userIndexResponseValue, userIndex); - CommandResponseInfo nextCredentialIndexResponseValue = new CommandResponseInfo("nextCredentialIndex", "Integer"); - responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedDoorLockClusterAttributeListAttributeCallback implements ChipClusters.DoorLockCluster.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 DelegatedElectricalMeasurementClusterAttributeListAttributeCallback implements ChipClusters.ElectricalMeasurementCluster.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 DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.EthernetNetworkDiagnosticsCluster.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 DelegatedFixedLabelClusterLabelListAttributeCallback implements ChipClusters.FixedLabelCluster.LabelListAttributeCallback, 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 DelegatedFixedLabelClusterAttributeListAttributeCallback implements ChipClusters.FixedLabelCluster.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 DelegatedFlowMeasurementClusterAttributeListAttributeCallback implements ChipClusters.FlowMeasurementCluster.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 DelegatedArmFailSafeResponseCallback implements ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedCommissioningCompleteResponseCallback implements ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSetRegulatoryConfigResponseCallback implements ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer errorCode, String debugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); - responseValues.put(errorCodeResponseValue, errorCode); - CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); - responseValues.put(debugTextResponseValue, debugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback implements ChipClusters.GeneralCommissioningCluster.BasicCommissioningInfoListAttributeCallback, 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 DelegatedGeneralCommissioningClusterAttributeListAttributeCallback implements ChipClusters.GeneralCommissioningCluster.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 DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback, 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 DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.GeneralDiagnosticsCluster.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 DelegatedKeySetReadAllIndicesResponseCallback implements ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ArrayList groupKeySetIDs) { - Map responseValues = new LinkedHashMap<>(); - // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedKeySetReadResponseCallback implements ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { - Map responseValues = new LinkedHashMap<>(); - // groupKeySet: Struct GroupKeySet - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback implements ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback, 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 DelegatedGroupKeyManagementClusterGroupTableAttributeCallback implements ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback, 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 DelegatedGroupKeyManagementClusterAttributeListAttributeCallback implements ChipClusters.GroupKeyManagementCluster.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 DelegatedAddGroupResponseCallback implements ChipClusters.GroupsCluster.AddGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetGroupMembershipResponseCallback implements ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer capacity, ArrayList groupList) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); - responseValues.put(capacityResponseValue, capacity); - // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveGroupResponseCallback implements ChipClusters.GroupsCluster.RemoveGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedViewGroupResponseCallback implements ChipClusters.GroupsCluster.ViewGroupResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, String groupName) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo groupNameResponseValue = new CommandResponseInfo("groupName", "String"); - responseValues.put(groupNameResponseValue, groupName); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedGroupsClusterAttributeListAttributeCallback implements ChipClusters.GroupsCluster.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 DelegatedIdentifyQueryResponseCallback implements ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer timeout) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo timeoutResponseValue = new CommandResponseInfo("timeout", "Integer"); - responseValues.put(timeoutResponseValue, timeout); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedIdentifyClusterAttributeListAttributeCallback implements ChipClusters.IdentifyCluster.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 DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback implements ChipClusters.IlluminanceMeasurementCluster.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 DelegatedSendKeyResponseCallback implements ChipClusters.KeypadInputCluster.SendKeyResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedKeypadInputClusterAttributeListAttributeCallback implements ChipClusters.KeypadInputCluster.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 DelegatedLevelControlClusterAttributeListAttributeCallback implements ChipClusters.LevelControlCluster.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 DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback implements ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback, 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 DelegatedLowPowerClusterAttributeListAttributeCallback implements ChipClusters.LowPowerCluster.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 DelegatedMediaInputClusterMediaInputListAttributeCallback implements ChipClusters.MediaInputCluster.MediaInputListAttributeCallback, 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 DelegatedMediaInputClusterAttributeListAttributeCallback implements ChipClusters.MediaInputCluster.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 DelegatedPlaybackResponseCallback implements ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedMediaPlaybackClusterAttributeListAttributeCallback implements ChipClusters.MediaPlaybackCluster.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 DelegatedModeSelectClusterSupportedModesAttributeCallback implements ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback, 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 DelegatedModeSelectClusterAttributeListAttributeCallback implements ChipClusters.ModeSelectCluster.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 DelegatedConnectNetworkResponseCallback implements ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText, Long ErrorValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - CommandResponseInfo ErrorValueResponseValue = new CommandResponseInfo("ErrorValue", "Long"); - responseValues.put(ErrorValueResponseValue, ErrorValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNetworkConfigResponseCallback implements ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedScanNetworksResponseCallback implements ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer NetworkingStatus, String DebugText, Optional> WiFiScanResults, Optional> ThreadScanResults) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NetworkingStatusResponseValue = new CommandResponseInfo("NetworkingStatus", "Integer"); - responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - // WiFiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - // ThreadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedNetworkCommissioningClusterNetworksAttributeCallback implements ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback, 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 DelegatedApplyUpdateResponseCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer action, Long delayedActionTime) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo actionResponseValue = new CommandResponseInfo("action", "Integer"); - responseValues.put(actionResponseValue, action); - CommandResponseInfo delayedActionTimeResponseValue = new CommandResponseInfo("delayedActionTime", "Long"); - responseValues.put(delayedActionTimeResponseValue, delayedActionTime); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedQueryImageResponseCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Optional delayedActionTime, Optional imageURI, Optional softwareVersion, Optional softwareVersionString, Optional updateToken, Optional userConsentNeeded, Optional metadataForRequestor) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo delayedActionTimeResponseValue = new CommandResponseInfo("delayedActionTime", "Optional"); - responseValues.put(delayedActionTimeResponseValue, delayedActionTime); - CommandResponseInfo imageURIResponseValue = new CommandResponseInfo("imageURI", "Optional"); - responseValues.put(imageURIResponseValue, imageURI); - CommandResponseInfo softwareVersionResponseValue = new CommandResponseInfo("softwareVersion", "Optional"); - responseValues.put(softwareVersionResponseValue, softwareVersion); - CommandResponseInfo softwareVersionStringResponseValue = new CommandResponseInfo("softwareVersionString", "Optional"); - responseValues.put(softwareVersionStringResponseValue, softwareVersionString); - CommandResponseInfo updateTokenResponseValue = new CommandResponseInfo("updateToken", "Optional"); - responseValues.put(updateTokenResponseValue, updateToken); - CommandResponseInfo userConsentNeededResponseValue = new CommandResponseInfo("userConsentNeeded", "Optional"); - responseValues.put(userConsentNeededResponseValue, userConsentNeeded); - CommandResponseInfo metadataForRequestorResponseValue = new CommandResponseInfo("metadataForRequestor", "Optional"); - responseValues.put(metadataForRequestorResponseValue, metadataForRequestor); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback implements ChipClusters.OtaSoftwareUpdateProviderCluster.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 DelegatedOtaSoftwareUpdateRequestorClusterDefaultOtaProvidersAttributeCallback implements ChipClusters.OtaSoftwareUpdateRequestorCluster.DefaultOtaProvidersAttributeCallback, 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 DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback implements ChipClusters.OtaSoftwareUpdateRequestorCluster.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 DelegatedOccupancySensingClusterAttributeListAttributeCallback implements ChipClusters.OccupancySensingCluster.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 DelegatedOnOffClusterAttributeListAttributeCallback implements ChipClusters.OnOffCluster.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 DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback implements ChipClusters.OnOffSwitchConfigurationCluster.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 DelegatedAttestationResponseCallback implements ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] AttestationElements, byte[] Signature) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo AttestationElementsResponseValue = new CommandResponseInfo("AttestationElements", "byte[]"); - responseValues.put(AttestationElementsResponseValue, AttestationElements); - CommandResponseInfo SignatureResponseValue = new CommandResponseInfo("Signature", "byte[]"); - responseValues.put(SignatureResponseValue, Signature); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedCertificateChainResponseCallback implements ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] Certificate) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo CertificateResponseValue = new CommandResponseInfo("Certificate", "byte[]"); - responseValues.put(CertificateResponseValue, Certificate); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedNOCResponseCallback implements ChipClusters.OperationalCredentialsCluster.NOCResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer StatusCode, Integer FabricIndex, String DebugText) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo StatusCodeResponseValue = new CommandResponseInfo("StatusCode", "Integer"); - responseValues.put(StatusCodeResponseValue, StatusCode); - CommandResponseInfo FabricIndexResponseValue = new CommandResponseInfo("FabricIndex", "Integer"); - responseValues.put(FabricIndexResponseValue, FabricIndex); - CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); - responseValues.put(DebugTextResponseValue, DebugText); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedOpCSRResponseCallback implements ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(byte[] NOCSRElements, byte[] AttestationSignature) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo NOCSRElementsResponseValue = new CommandResponseInfo("NOCSRElements", "byte[]"); - responseValues.put(NOCSRElementsResponseValue, NOCSRElements); - CommandResponseInfo AttestationSignatureResponseValue = new CommandResponseInfo("AttestationSignature", "byte[]"); - responseValues.put(AttestationSignatureResponseValue, AttestationSignature); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedOperationalCredentialsClusterNOCsAttributeCallback implements ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback, 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 DelegatedOperationalCredentialsClusterFabricsListAttributeCallback implements ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback, 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 DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback implements ChipClusters.OperationalCredentialsCluster.TrustedRootCertificatesAttributeCallback, 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 DelegatedOperationalCredentialsClusterAttributeListAttributeCallback implements ChipClusters.OperationalCredentialsCluster.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 DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback implements ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback, 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 DelegatedPowerSourceClusterAttributeListAttributeCallback implements ChipClusters.PowerSourceCluster.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 DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback implements ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback, 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 DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback implements ChipClusters.PowerSourceConfigurationCluster.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 DelegatedPressureMeasurementClusterAttributeListAttributeCallback implements ChipClusters.PressureMeasurementCluster.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 DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback implements ChipClusters.PumpConfigurationAndControlCluster.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 DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback implements ChipClusters.RelativeHumidityMeasurementCluster.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 DelegatedAddSceneResponseCallback implements ChipClusters.ScenesCluster.AddSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetSceneMembershipResponseCallback implements ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer capacity, Integer groupId, Integer sceneCount, ArrayList sceneList) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); - responseValues.put(capacityResponseValue, capacity); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneCountResponseValue = new CommandResponseInfo("sceneCount", "Integer"); - responseValues.put(sceneCountResponseValue, sceneCount); - // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveAllScenesResponseCallback implements ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedRemoveSceneResponseCallback implements ChipClusters.ScenesCluster.RemoveSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedStoreSceneResponseCallback implements ChipClusters.ScenesCluster.StoreSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedViewSceneResponseCallback implements ChipClusters.ScenesCluster.ViewSceneResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, Integer groupId, Integer sceneId, Integer transitionTime, String sceneName, ArrayList extensionFieldSets) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); - responseValues.put(groupIdResponseValue, groupId); - CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); - responseValues.put(sceneIdResponseValue, sceneId); - CommandResponseInfo transitionTimeResponseValue = new CommandResponseInfo("transitionTime", "Integer"); - responseValues.put(transitionTimeResponseValue, transitionTime); - CommandResponseInfo sceneNameResponseValue = new CommandResponseInfo("sceneName", "String"); - responseValues.put(sceneNameResponseValue, sceneName); - // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedScenesClusterAttributeListAttributeCallback implements ChipClusters.ScenesCluster.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 DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback implements ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback, 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 DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.SoftwareDiagnosticsCluster.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 DelegatedSwitchClusterAttributeListAttributeCallback implements ChipClusters.SwitchCluster.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 DelegatedNavigateTargetResponseCallback implements ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer status, String data) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); - responseValues.put(statusResponseValue, status); - CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); - responseValues.put(dataResponseValue, data); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - - public static class DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback implements ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback, 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 DelegatedTargetNavigatorClusterAttributeListAttributeCallback implements ChipClusters.TargetNavigatorCluster.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 DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback implements ChipClusters.TemperatureMeasurementCluster.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 DelegatedBooleanResponseCallback implements ChipClusters.TestClusterCluster.BooleanResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Boolean value) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Boolean"); - responseValues.put(valueResponseValue, value); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedSimpleStructResponseCallback implements ChipClusters.TestClusterCluster.SimpleStructResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1) { - Map responseValues = new LinkedHashMap<>(); - // arg1: Struct SimpleStruct - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestAddArgumentsResponseCallback implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer returnValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo returnValueResponseValue = new CommandResponseInfo("returnValue", "Integer"); - responseValues.put(returnValueResponseValue, returnValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestEmitTestEventResponseCallback implements ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Long value) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Long"); - responseValues.put(valueResponseValue, value); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestEnumsResponseCallback implements ChipClusters.TestClusterCluster.TestEnumsResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer arg1, Integer arg2) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo arg1ResponseValue = new CommandResponseInfo("arg1", "Integer"); - responseValues.put(arg1ResponseValue, arg1); - CommandResponseInfo arg2ResponseValue = new CommandResponseInfo("arg2", "Integer"); - responseValues.put(arg2ResponseValue, arg2); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestListInt8UReverseResponseCallback implements ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(ArrayList arg1) { - Map responseValues = new LinkedHashMap<>(); - // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestNullableOptionalResponseCallback implements ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Boolean wasPresent, Optional wasNull, Optional value, @Nullable Optional originalValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo wasPresentResponseValue = new CommandResponseInfo("wasPresent", "Boolean"); - responseValues.put(wasPresentResponseValue, wasPresent); - CommandResponseInfo wasNullResponseValue = new CommandResponseInfo("wasNull", "Optional"); - responseValues.put(wasNullResponseValue, wasNull); - CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Optional"); - responseValues.put(valueResponseValue, value); - CommandResponseInfo originalValueResponseValue = new CommandResponseInfo("originalValue", "Optional"); - responseValues.put(originalValueResponseValue, originalValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedTestSpecificResponseCallback implements ChipClusters.TestClusterCluster.TestSpecificResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer returnValue) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo returnValueResponseValue = new CommandResponseInfo("returnValue", "Integer"); - responseValues.put(returnValueResponseValue, returnValue); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedTestClusterClusterListInt8uAttributeCallback implements ChipClusters.TestClusterCluster.ListInt8uAttributeCallback, 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 DelegatedTestClusterClusterListOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback, 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 DelegatedTestClusterClusterListStructOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback, 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 DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback implements ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback, 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 DelegatedTestClusterClusterListLongOctetStringAttributeCallback implements ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback, 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 DelegatedTestClusterClusterAttributeListAttributeCallback implements ChipClusters.TestClusterCluster.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 DelegatedGetRelayStatusLogResponseCallback implements ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer timeOfDay, Integer relayStatus, Integer localTemperature, Integer humidityInPercentage, Integer setpoint, Integer unreadEntries) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo timeOfDayResponseValue = new CommandResponseInfo("timeOfDay", "Integer"); - responseValues.put(timeOfDayResponseValue, timeOfDay); - CommandResponseInfo relayStatusResponseValue = new CommandResponseInfo("relayStatus", "Integer"); - responseValues.put(relayStatusResponseValue, relayStatus); - CommandResponseInfo localTemperatureResponseValue = new CommandResponseInfo("localTemperature", "Integer"); - responseValues.put(localTemperatureResponseValue, localTemperature); - CommandResponseInfo humidityInPercentageResponseValue = new CommandResponseInfo("humidityInPercentage", "Integer"); - responseValues.put(humidityInPercentageResponseValue, humidityInPercentage); - CommandResponseInfo setpointResponseValue = new CommandResponseInfo("setpoint", "Integer"); - responseValues.put(setpointResponseValue, setpoint); - CommandResponseInfo unreadEntriesResponseValue = new CommandResponseInfo("unreadEntries", "Integer"); - responseValues.put(unreadEntriesResponseValue, unreadEntries); - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - public static class DelegatedGetWeeklyScheduleResponseCallback implements ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback, DelegatedClusterCallback { - private ClusterCommandCallback callback; - @Override - public void setCallbackDelegate(ClusterCommandCallback callback) { - this.callback = callback; - } - - @Override - public void onSuccess(Integer numberOfTransitionsForSequence, Integer dayOfWeekForSequence, Integer modeForSequence, ArrayList payload) { - Map responseValues = new LinkedHashMap<>(); - CommandResponseInfo numberOfTransitionsForSequenceResponseValue = new CommandResponseInfo("numberOfTransitionsForSequence", "Integer"); - responseValues.put(numberOfTransitionsForSequenceResponseValue, numberOfTransitionsForSequence); - CommandResponseInfo dayOfWeekForSequenceResponseValue = new CommandResponseInfo("dayOfWeekForSequence", "Integer"); - responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); - CommandResponseInfo modeForSequenceResponseValue = new CommandResponseInfo("modeForSequence", "Integer"); - responseValues.put(modeForSequenceResponseValue, modeForSequence); - // payload: /* TYPE WARNING: array array defaults to */ uint8_t * - // Conversion from this type to Java is not properly implemented yet - callback.onSuccess(responseValues); - } - - @Override - public void onError(Exception error) { - callback.onFailure(error); - } - } - - - public static class DelegatedThermostatClusterAttributeListAttributeCallback implements ChipClusters.ThermostatCluster.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 DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback implements ChipClusters.ThermostatUserInterfaceConfigurationCluster.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 DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.OperationalDatasetComponentsAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback, 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 DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.ThreadNetworkDiagnosticsCluster.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 DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback implements ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback, 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 DelegatedUserLabelClusterLabelListAttributeCallback implements ChipClusters.UserLabelCluster.LabelListAttributeCallback, 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 DelegatedWakeOnLanClusterAttributeListAttributeCallback implements ChipClusters.WakeOnLanCluster.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 DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback implements ChipClusters.WiFiNetworkDiagnosticsCluster.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 DelegatedWindowCoveringClusterAttributeListAttributeCallback implements ChipClusters.WindowCoveringCluster.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 Map getClusterMap() { - Map clusterMap = initializeClusterMap(); - Map> commandMap = getCommandMap(); - combineCommand(clusterMap, commandMap); - Map> readAttributeMap = new ClusterReadMapping().getReadAttributeMap(); - combineCommand(clusterMap, readAttributeMap); - Map> writeAttributeMap = new ClusterWriteMapping().getWriteAttributeMap(); - combineCommand(clusterMap, writeAttributeMap); - return clusterMap; - } + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } - public Map initializeClusterMap() { - Map clusterMap = new HashMap<>(); - ClusterInfo accessControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AccessControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("accessControl", accessControlClusterInfo); - ClusterInfo accountLoginClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("accountLogin", accountLoginClusterInfo); - ClusterInfo administratorCommissioningClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); - ClusterInfo applicationBasicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("applicationBasic", applicationBasicClusterInfo); - ClusterInfo applicationLauncherClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); - ClusterInfo audioOutputClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("audioOutput", audioOutputClusterInfo); - ClusterInfo barrierControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("barrierControl", barrierControlClusterInfo); - ClusterInfo basicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("basic", basicClusterInfo); - ClusterInfo binaryInputBasicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); - ClusterInfo bindingClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("binding", bindingClusterInfo); - ClusterInfo booleanStateClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("booleanState", booleanStateClusterInfo); - ClusterInfo bridgedActionsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("bridgedActions", bridgedActionsClusterInfo); - ClusterInfo bridgedDeviceBasicClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); - ClusterInfo channelClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ChannelCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("channel", channelClusterInfo); - ClusterInfo colorControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("colorControl", colorControlClusterInfo); - ClusterInfo contentLauncherClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("contentLauncher", contentLauncherClusterInfo); - ClusterInfo descriptorClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("descriptor", descriptorClusterInfo); - ClusterInfo diagnosticLogsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); - ClusterInfo doorLockClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("doorLock", doorLockClusterInfo); - ClusterInfo electricalMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); - ClusterInfo ethernetNetworkDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); - ClusterInfo fixedLabelClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("fixedLabel", fixedLabelClusterInfo); - ClusterInfo flowMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); - ClusterInfo generalCommissioningClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); - ClusterInfo generalDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); - ClusterInfo groupKeyManagementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); - ClusterInfo groupsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("groups", groupsClusterInfo); - ClusterInfo identifyClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("identify", identifyClusterInfo); - ClusterInfo illuminanceMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); - ClusterInfo keypadInputClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("keypadInput", keypadInputClusterInfo); - ClusterInfo levelControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("levelControl", levelControlClusterInfo); - ClusterInfo localizationConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LocalizationConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("localizationConfiguration", localizationConfigurationClusterInfo); - ClusterInfo lowPowerClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("lowPower", lowPowerClusterInfo); - ClusterInfo mediaInputClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("mediaInput", mediaInputClusterInfo); - ClusterInfo mediaPlaybackClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); - ClusterInfo modeSelectClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("modeSelect", modeSelectClusterInfo); - ClusterInfo networkCommissioningClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); - ClusterInfo otaSoftwareUpdateProviderClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); - ClusterInfo otaSoftwareUpdateRequestorClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); - ClusterInfo occupancySensingClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("occupancySensing", occupancySensingClusterInfo); - ClusterInfo onOffClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("onOff", onOffClusterInfo); - ClusterInfo onOffSwitchConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); - ClusterInfo operationalCredentialsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); - ClusterInfo powerSourceClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("powerSource", powerSourceClusterInfo); - ClusterInfo powerSourceConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PowerSourceConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInfo); - ClusterInfo pressureMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); - ClusterInfo pumpConfigurationAndControlClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); - ClusterInfo relativeHumidityMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); - ClusterInfo scenesClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("scenes", scenesClusterInfo); - ClusterInfo softwareDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); - ClusterInfo switchClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("switch", switchClusterInfo); - ClusterInfo targetNavigatorClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("targetNavigator", targetNavigatorClusterInfo); - ClusterInfo temperatureMeasurementClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); - ClusterInfo testClusterClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("testCluster", testClusterClusterInfo); - ClusterInfo thermostatClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("thermostat", thermostatClusterInfo); - ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); - ClusterInfo threadNetworkDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); - ClusterInfo timeFormatLocalizationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.TimeFormatLocalizationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("timeFormatLocalization", timeFormatLocalizationClusterInfo); - ClusterInfo unitLocalizationClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.UnitLocalizationCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("unitLocalization", unitLocalizationClusterInfo); - ClusterInfo userLabelClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.UserLabelCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("userLabel", userLabelClusterInfo); - ClusterInfo wakeOnLanClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); - ClusterInfo wiFiNetworkDiagnosticsClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); - ClusterInfo windowCoveringClusterInfo = new ClusterInfo( - (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), new HashMap<>()); - clusterMap.put("windowCovering", windowCoveringClusterInfo); - return clusterMap; - } - - public void combineCommand(Map destination, Map> source) { - destination.get("accessControl").combineCommands(source.get("accessControl")); - destination.get("accountLogin").combineCommands(source.get("accountLogin")); - destination.get("administratorCommissioning").combineCommands(source.get("administratorCommissioning")); - destination.get("applicationBasic").combineCommands(source.get("applicationBasic")); - destination.get("applicationLauncher").combineCommands(source.get("applicationLauncher")); - destination.get("audioOutput").combineCommands(source.get("audioOutput")); - destination.get("barrierControl").combineCommands(source.get("barrierControl")); - destination.get("basic").combineCommands(source.get("basic")); - destination.get("binaryInputBasic").combineCommands(source.get("binaryInputBasic")); - destination.get("binding").combineCommands(source.get("binding")); - destination.get("booleanState").combineCommands(source.get("booleanState")); - destination.get("bridgedActions").combineCommands(source.get("bridgedActions")); - destination.get("bridgedDeviceBasic").combineCommands(source.get("bridgedDeviceBasic")); - destination.get("channel").combineCommands(source.get("channel")); - destination.get("colorControl").combineCommands(source.get("colorControl")); - destination.get("contentLauncher").combineCommands(source.get("contentLauncher")); - destination.get("descriptor").combineCommands(source.get("descriptor")); - destination.get("diagnosticLogs").combineCommands(source.get("diagnosticLogs")); - destination.get("doorLock").combineCommands(source.get("doorLock")); - destination.get("electricalMeasurement").combineCommands(source.get("electricalMeasurement")); - destination.get("ethernetNetworkDiagnostics").combineCommands(source.get("ethernetNetworkDiagnostics")); - destination.get("fixedLabel").combineCommands(source.get("fixedLabel")); - destination.get("flowMeasurement").combineCommands(source.get("flowMeasurement")); - destination.get("generalCommissioning").combineCommands(source.get("generalCommissioning")); - destination.get("generalDiagnostics").combineCommands(source.get("generalDiagnostics")); - destination.get("groupKeyManagement").combineCommands(source.get("groupKeyManagement")); - destination.get("groups").combineCommands(source.get("groups")); - destination.get("identify").combineCommands(source.get("identify")); - destination.get("illuminanceMeasurement").combineCommands(source.get("illuminanceMeasurement")); - destination.get("keypadInput").combineCommands(source.get("keypadInput")); - destination.get("levelControl").combineCommands(source.get("levelControl")); - destination.get("localizationConfiguration").combineCommands(source.get("localizationConfiguration")); - destination.get("lowPower").combineCommands(source.get("lowPower")); - destination.get("mediaInput").combineCommands(source.get("mediaInput")); - destination.get("mediaPlayback").combineCommands(source.get("mediaPlayback")); - destination.get("modeSelect").combineCommands(source.get("modeSelect")); - destination.get("networkCommissioning").combineCommands(source.get("networkCommissioning")); - destination.get("otaSoftwareUpdateProvider").combineCommands(source.get("otaSoftwareUpdateProvider")); - destination.get("otaSoftwareUpdateRequestor").combineCommands(source.get("otaSoftwareUpdateRequestor")); - destination.get("occupancySensing").combineCommands(source.get("occupancySensing")); - destination.get("onOff").combineCommands(source.get("onOff")); - destination.get("onOffSwitchConfiguration").combineCommands(source.get("onOffSwitchConfiguration")); - destination.get("operationalCredentials").combineCommands(source.get("operationalCredentials")); - destination.get("powerSource").combineCommands(source.get("powerSource")); - destination.get("powerSourceConfiguration").combineCommands(source.get("powerSourceConfiguration")); - destination.get("pressureMeasurement").combineCommands(source.get("pressureMeasurement")); - destination.get("pumpConfigurationAndControl").combineCommands(source.get("pumpConfigurationAndControl")); - destination.get("relativeHumidityMeasurement").combineCommands(source.get("relativeHumidityMeasurement")); - destination.get("scenes").combineCommands(source.get("scenes")); - destination.get("softwareDiagnostics").combineCommands(source.get("softwareDiagnostics")); - destination.get("switch").combineCommands(source.get("switch")); - destination.get("targetNavigator").combineCommands(source.get("targetNavigator")); - destination.get("temperatureMeasurement").combineCommands(source.get("temperatureMeasurement")); - destination.get("testCluster").combineCommands(source.get("testCluster")); - destination.get("thermostat").combineCommands(source.get("thermostat")); - destination.get("thermostatUserInterfaceConfiguration").combineCommands(source.get("thermostatUserInterfaceConfiguration")); - destination.get("threadNetworkDiagnostics").combineCommands(source.get("threadNetworkDiagnostics")); - destination.get("timeFormatLocalization").combineCommands(source.get("timeFormatLocalization")); - destination.get("unitLocalization").combineCommands(source.get("unitLocalization")); - destination.get("userLabel").combineCommands(source.get("userLabel")); - destination.get("wakeOnLan").combineCommands(source.get("wakeOnLan")); - destination.get("wiFiNetworkDiagnostics").combineCommands(source.get("wiFiNetworkDiagnostics")); - destination.get("windowCovering").combineCommands(source.get("windowCovering")); - } - - @SuppressWarnings("unchecked") - public Map> getCommandMap() { - Map> commandMap = new HashMap<>(); - Map accessControlClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("accessControl", accessControlClusterInteractionInfoMap); - Map accountLoginClusterInteractionInfoMap = new LinkedHashMap<>(); - Map accountLogingetSetupPINRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); - accountLogingetSetupPINRequestCommandParams.put("tempAccountIdentifier",accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); - - InteractionInfo accountLogingetSetupPINRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .getSetupPINRequest((ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback) callback - , (String) - commandArguments.get("tempAccountIdentifier") - , 10000 - ); - }, - () -> new DelegatedGetSetupPINResponseCallback(), - accountLogingetSetupPINRequestCommandParams - ); - accountLoginClusterInteractionInfoMap.put("getSetupPINRequest", accountLogingetSetupPINRequestInteractionInfo); - Map accountLoginloginRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = new CommandParameterInfo("tempAccountIdentifier", String.class); - accountLoginloginRequestCommandParams.put("tempAccountIdentifier",accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); - - CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = new CommandParameterInfo("setupPIN", String.class); - accountLoginloginRequestCommandParams.put("setupPIN",accountLoginloginRequestsetupPINCommandParameterInfo); - - InteractionInfo accountLoginloginRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .loginRequest((DefaultClusterCallback) callback - , (String) - commandArguments.get("tempAccountIdentifier") - , (String) - commandArguments.get("setupPIN") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - accountLoginloginRequestCommandParams - ); - accountLoginClusterInteractionInfoMap.put("loginRequest", accountLoginloginRequestInteractionInfo); - Map accountLoginlogoutRequestCommandParams = new LinkedHashMap(); - InteractionInfo accountLoginlogoutRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster) - .logoutRequest((DefaultClusterCallback) callback - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - accountLoginlogoutRequestCommandParams - ); - accountLoginClusterInteractionInfoMap.put("logoutRequest", accountLoginlogoutRequestInteractionInfo); - commandMap.put("accountLogin", accountLoginClusterInteractionInfoMap); - Map administratorCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); - Map administratorCommissioningopenBasicCommissioningWindowCommandParams = new LinkedHashMap(); - CommandParameterInfo administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); - administratorCommissioningopenBasicCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); - - InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .openBasicCommissioningWindow((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("commissioningTimeout") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningopenBasicCommissioningWindowCommandParams - ); - administratorCommissioningClusterInteractionInfoMap.put("openBasicCommissioningWindow", administratorCommissioningopenBasicCommissioningWindowInteractionInfo); - Map administratorCommissioningopenCommissioningWindowCommandParams = new LinkedHashMap(); - CommandParameterInfo administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = new CommandParameterInfo("commissioningTimeout", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("commissioningTimeout",administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = new CommandParameterInfo("PAKEVerifier", byte[].class); - administratorCommissioningopenCommissioningWindowCommandParams.put("PAKEVerifier",administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = new CommandParameterInfo("discriminator", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("discriminator",administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = new CommandParameterInfo("iterations", Long.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("iterations",administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = new CommandParameterInfo("salt", byte[].class); - administratorCommissioningopenCommissioningWindowCommandParams.put("salt",administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); - - CommandParameterInfo administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = new CommandParameterInfo("passcodeID", Integer.class); - administratorCommissioningopenCommissioningWindowCommandParams.put("passcodeID",administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); - - InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .openCommissioningWindow((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("commissioningTimeout") - , (byte[]) - commandArguments.get("PAKEVerifier") - , (Integer) - commandArguments.get("discriminator") - , (Long) - commandArguments.get("iterations") - , (byte[]) - commandArguments.get("salt") - , (Integer) - commandArguments.get("passcodeID") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningopenCommissioningWindowCommandParams - ); - administratorCommissioningClusterInteractionInfoMap.put("openCommissioningWindow", administratorCommissioningopenCommissioningWindowInteractionInfo); - Map administratorCommissioningrevokeCommissioningCommandParams = new LinkedHashMap(); - InteractionInfo administratorCommissioningrevokeCommissioningInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster) - .revokeCommissioning((DefaultClusterCallback) callback - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - administratorCommissioningrevokeCommissioningCommandParams - ); - administratorCommissioningClusterInteractionInfoMap.put("revokeCommissioning", administratorCommissioningrevokeCommissioningInteractionInfo); - commandMap.put("administratorCommissioning", administratorCommissioningClusterInteractionInfoMap); - Map applicationBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("applicationBasic", applicationBasicClusterInteractionInfoMap); - Map applicationLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); - Map applicationLauncherhideAppRequestCommandParams = new LinkedHashMap(); - InteractionInfo applicationLauncherhideAppRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .hideAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback - , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application") - - ); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherhideAppRequestCommandParams - ); - applicationLauncherClusterInteractionInfoMap.put("hideAppRequest", applicationLauncherhideAppRequestInteractionInfo); - Map applicationLauncherlaunchAppRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); - applicationLauncherlaunchAppRequestCommandParams.put("data",applicationLauncherlaunchAppRequestdataCommandParameterInfo); - - InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .launchAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback - , (String) - commandArguments.get("data") - , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application") - - ); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherlaunchAppRequestCommandParams - ); - applicationLauncherClusterInteractionInfoMap.put("launchAppRequest", applicationLauncherlaunchAppRequestInteractionInfo); - Map applicationLauncherstopAppRequestCommandParams = new LinkedHashMap(); - InteractionInfo applicationLauncherstopAppRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster) - .stopAppRequest((ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback - , (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) - commandArguments.get("application") - - ); - }, - () -> new DelegatedLauncherResponseCallback(), - applicationLauncherstopAppRequestCommandParams - ); - applicationLauncherClusterInteractionInfoMap.put("stopAppRequest", applicationLauncherstopAppRequestInteractionInfo); - commandMap.put("applicationLauncher", applicationLauncherClusterInteractionInfoMap); - Map audioOutputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map audioOutputrenameOutputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - audioOutputrenameOutputRequestCommandParams.put("index",audioOutputrenameOutputRequestindexCommandParameterInfo); - - CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); - audioOutputrenameOutputRequestCommandParams.put("name",audioOutputrenameOutputRequestnameCommandParameterInfo); - - InteractionInfo audioOutputrenameOutputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .renameOutputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - , (String) - commandArguments.get("name") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - audioOutputrenameOutputRequestCommandParams - ); - audioOutputClusterInteractionInfoMap.put("renameOutputRequest", audioOutputrenameOutputRequestInteractionInfo); - Map audioOutputselectOutputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - audioOutputselectOutputRequestCommandParams.put("index",audioOutputselectOutputRequestindexCommandParameterInfo); - - InteractionInfo audioOutputselectOutputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster) - .selectOutputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - audioOutputselectOutputRequestCommandParams - ); - audioOutputClusterInteractionInfoMap.put("selectOutputRequest", audioOutputselectOutputRequestInteractionInfo); - commandMap.put("audioOutput", audioOutputClusterInteractionInfoMap); - Map barrierControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map barrierControlbarrierControlGoToPercentCommandParams = new LinkedHashMap(); - CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = new CommandParameterInfo("percentOpen", Integer.class); - barrierControlbarrierControlGoToPercentCommandParams.put("percentOpen",barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); - - InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .barrierControlGoToPercent((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("percentOpen") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - barrierControlbarrierControlGoToPercentCommandParams - ); - barrierControlClusterInteractionInfoMap.put("barrierControlGoToPercent", barrierControlbarrierControlGoToPercentInteractionInfo); - Map barrierControlbarrierControlStopCommandParams = new LinkedHashMap(); - InteractionInfo barrierControlbarrierControlStopInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster) - .barrierControlStop((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - barrierControlbarrierControlStopCommandParams - ); - barrierControlClusterInteractionInfoMap.put("barrierControlStop", barrierControlbarrierControlStopInteractionInfo); - commandMap.put("barrierControl", barrierControlClusterInteractionInfoMap); - Map basicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("basic", basicClusterInteractionInfoMap); - Map binaryInputBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("binaryInputBasic", binaryInputBasicClusterInteractionInfoMap); - Map bindingClusterInteractionInfoMap = new LinkedHashMap<>(); - Map bindingbindCommandParams = new LinkedHashMap(); - CommandParameterInfo bindingbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); - bindingbindCommandParams.put("nodeId",bindingbindnodeIdCommandParameterInfo); - - CommandParameterInfo bindingbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - bindingbindCommandParams.put("groupId",bindingbindgroupIdCommandParameterInfo); - - CommandParameterInfo bindingbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); - bindingbindCommandParams.put("endpointId",bindingbindendpointIdCommandParameterInfo); - - CommandParameterInfo bindingbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); - bindingbindCommandParams.put("clusterId",bindingbindclusterIdCommandParameterInfo); - - InteractionInfo bindingbindInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .bind((DefaultClusterCallback) callback - , (Long) - commandArguments.get("nodeId") - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("endpointId") - , (Long) - commandArguments.get("clusterId") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bindingbindCommandParams - ); - bindingClusterInteractionInfoMap.put("bind", bindingbindInteractionInfo); - Map bindingunbindCommandParams = new LinkedHashMap(); - CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = new CommandParameterInfo("nodeId", Long.class); - bindingunbindCommandParams.put("nodeId",bindingunbindnodeIdCommandParameterInfo); - - CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - bindingunbindCommandParams.put("groupId",bindingunbindgroupIdCommandParameterInfo); - - CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = new CommandParameterInfo("endpointId", Integer.class); - bindingunbindCommandParams.put("endpointId",bindingunbindendpointIdCommandParameterInfo); - - CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = new CommandParameterInfo("clusterId", Long.class); - bindingunbindCommandParams.put("clusterId",bindingunbindclusterIdCommandParameterInfo); - - InteractionInfo bindingunbindInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster) - .unbind((DefaultClusterCallback) callback - , (Long) - commandArguments.get("nodeId") - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("endpointId") - , (Long) - commandArguments.get("clusterId") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bindingunbindCommandParams - ); - bindingClusterInteractionInfoMap.put("unbind", bindingunbindInteractionInfo); - commandMap.put("binding", bindingClusterInteractionInfoMap); - Map booleanStateClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("booleanState", booleanStateClusterInteractionInfoMap); - Map bridgedActionsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map bridgedActionsdisableActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsdisableActionCommandParams.put("actionID",bridgedActionsdisableActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsdisableActionCommandParams.put("invokeID",bridgedActionsdisableActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsdisableActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .disableAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsdisableActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("disableAction", bridgedActionsdisableActionInteractionInfo); - Map bridgedActionsdisableActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsdisableActionWithDurationCommandParams.put("actionID",bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsdisableActionWithDurationCommandParams.put("invokeID",bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionsdisableActionWithDurationCommandParams.put("duration",bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .disableActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsdisableActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("disableActionWithDuration", bridgedActionsdisableActionWithDurationInteractionInfo); - Map bridgedActionsenableActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsenableActionCommandParams.put("actionID",bridgedActionsenableActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsenableActionCommandParams.put("invokeID",bridgedActionsenableActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsenableActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .enableAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsenableActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("enableAction", bridgedActionsenableActionInteractionInfo); - Map bridgedActionsenableActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsenableActionWithDurationCommandParams.put("actionID",bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsenableActionWithDurationCommandParams.put("invokeID",bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionsenableActionWithDurationCommandParams.put("duration",bridgedActionsenableActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .enableActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsenableActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("enableActionWithDuration", bridgedActionsenableActionWithDurationInteractionInfo); - Map bridgedActionsinstantActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsinstantActionCommandParams.put("actionID",bridgedActionsinstantActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsinstantActionCommandParams.put("invokeID",bridgedActionsinstantActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsinstantActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .instantAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsinstantActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("instantAction", bridgedActionsinstantActionInteractionInfo); - Map bridgedActionsinstantActionWithTransitionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsinstantActionWithTransitionCommandParams.put("actionID",bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsinstantActionWithTransitionCommandParams.put("invokeID",bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - bridgedActionsinstantActionWithTransitionCommandParams.put("transitionTime",bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); - - InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .instantActionWithTransition((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsinstantActionWithTransitionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("instantActionWithTransition", bridgedActionsinstantActionWithTransitionInteractionInfo); - Map bridgedActionspauseActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionspauseActionCommandParams.put("actionID",bridgedActionspauseActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionspauseActionCommandParams.put("invokeID",bridgedActionspauseActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionspauseActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .pauseAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionspauseActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("pauseAction", bridgedActionspauseActionInteractionInfo); - Map bridgedActionspauseActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionspauseActionWithDurationCommandParams.put("actionID",bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionspauseActionWithDurationCommandParams.put("invokeID",bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionspauseActionWithDurationCommandParams.put("duration",bridgedActionspauseActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .pauseActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionspauseActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("pauseActionWithDuration", bridgedActionspauseActionWithDurationInteractionInfo); - Map bridgedActionsresumeActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsresumeActionCommandParams.put("actionID",bridgedActionsresumeActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsresumeActionCommandParams.put("invokeID",bridgedActionsresumeActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsresumeActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .resumeAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsresumeActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("resumeAction", bridgedActionsresumeActionInteractionInfo); - Map bridgedActionsstartActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstartActionCommandParams.put("actionID",bridgedActionsstartActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstartActionCommandParams.put("invokeID",bridgedActionsstartActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsstartActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .startAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstartActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("startAction", bridgedActionsstartActionInteractionInfo); - Map bridgedActionsstartActionWithDurationCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstartActionWithDurationCommandParams.put("actionID",bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstartActionWithDurationCommandParams.put("invokeID",bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = new CommandParameterInfo("duration", Long.class); - bridgedActionsstartActionWithDurationCommandParams.put("duration",bridgedActionsstartActionWithDurationdurationCommandParameterInfo); - - InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .startActionWithDuration((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - , (Long) - commandArguments.get("duration") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstartActionWithDurationCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("startActionWithDuration", bridgedActionsstartActionWithDurationInteractionInfo); - Map bridgedActionsstopActionCommandParams = new LinkedHashMap(); - CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = new CommandParameterInfo("actionID", Integer.class); - bridgedActionsstopActionCommandParams.put("actionID",bridgedActionsstopActionactionIDCommandParameterInfo); - - CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = new CommandParameterInfo("invokeID", Optional.class); - bridgedActionsstopActionCommandParams.put("invokeID",bridgedActionsstopActioninvokeIDCommandParameterInfo); - - InteractionInfo bridgedActionsstopActionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster) - .stopAction((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("actionID") - , (Optional) - commandArguments.get("invokeID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - bridgedActionsstopActionCommandParams - ); - bridgedActionsClusterInteractionInfoMap.put("stopAction", bridgedActionsstopActionInteractionInfo); - commandMap.put("bridgedActions", bridgedActionsClusterInteractionInfoMap); - Map bridgedDeviceBasicClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInteractionInfoMap); - Map channelClusterInteractionInfoMap = new LinkedHashMap<>(); - Map channelchangeChannelByNumberRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = new CommandParameterInfo("majorNumber", Integer.class); - channelchangeChannelByNumberRequestCommandParams.put("majorNumber",channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); - - CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = new CommandParameterInfo("minorNumber", Integer.class); - channelchangeChannelByNumberRequestCommandParams.put("minorNumber",channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); - - InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .changeChannelByNumberRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("majorNumber") - , (Integer) - commandArguments.get("minorNumber") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - channelchangeChannelByNumberRequestCommandParams - ); - channelClusterInteractionInfoMap.put("changeChannelByNumberRequest", channelchangeChannelByNumberRequestInteractionInfo); - Map channelchangeChannelRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = new CommandParameterInfo("match", String.class); - channelchangeChannelRequestCommandParams.put("match",channelchangeChannelRequestmatchCommandParameterInfo); - - InteractionInfo channelchangeChannelRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .changeChannelRequest((ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback - , (String) - commandArguments.get("match") - - ); - }, - () -> new DelegatedChangeChannelResponseCallback(), - channelchangeChannelRequestCommandParams - ); - channelClusterInteractionInfoMap.put("changeChannelRequest", channelchangeChannelRequestInteractionInfo); - Map channelskipChannelRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = new CommandParameterInfo("count", Integer.class); - channelskipChannelRequestCommandParams.put("count",channelskipChannelRequestcountCommandParameterInfo); - - InteractionInfo channelskipChannelRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster) - .skipChannelRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("count") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - channelskipChannelRequestCommandParams - ); - channelClusterInteractionInfoMap.put("skipChannelRequest", channelskipChannelRequestInteractionInfo); - commandMap.put("channel", channelClusterInteractionInfoMap); - Map colorControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map colorControlcolorLoopSetCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = new CommandParameterInfo("updateFlags", Integer.class); - colorControlcolorLoopSetCommandParams.put("updateFlags",colorControlcolorLoopSetupdateFlagsCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = new CommandParameterInfo("action", Integer.class); - colorControlcolorLoopSetCommandParams.put("action",colorControlcolorLoopSetactionCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); - colorControlcolorLoopSetCommandParams.put("direction",colorControlcolorLoopSetdirectionCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = new CommandParameterInfo("time", Integer.class); - colorControlcolorLoopSetCommandParams.put("time",colorControlcolorLoopSettimeCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = new CommandParameterInfo("startHue", Integer.class); - colorControlcolorLoopSetCommandParams.put("startHue",colorControlcolorLoopSetstartHueCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlcolorLoopSetCommandParams.put("optionsMask",colorControlcolorLoopSetoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlcolorLoopSetCommandParams.put("optionsOverride",colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlcolorLoopSetInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .colorLoopSet((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("updateFlags") - , (Integer) - commandArguments.get("action") - , (Integer) - commandArguments.get("direction") - , (Integer) - commandArguments.get("time") - , (Integer) - commandArguments.get("startHue") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlcolorLoopSetCommandParams - ); - colorControlClusterInteractionInfoMap.put("colorLoopSet", colorControlcolorLoopSetInteractionInfo); - Map colorControlenhancedMoveHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlenhancedMoveHueCommandParams.put("moveMode",colorControlenhancedMoveHuemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlenhancedMoveHueCommandParams.put("rate",colorControlenhancedMoveHuerateCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveHueCommandParams.put("optionsMask",colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveHueCommandParams.put("optionsOverride",colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedMoveHue", colorControlenhancedMoveHueInteractionInfo); - Map colorControlenhancedMoveToHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("enhancedHue",colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("direction",colorControlenhancedMoveToHuedirectionCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("transitionTime",colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("optionsMask",colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveToHueCommandParams.put("optionsOverride",colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveToHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveToHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("enhancedHue") - , (Integer) - commandArguments.get("direction") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveToHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedMoveToHue", colorControlenhancedMoveToHueInteractionInfo); - Map colorControlenhancedMoveToHueAndSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = new CommandParameterInfo("enhancedHue", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("enhancedHue",colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("saturation",colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("transitionTime",colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsMask",colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedMoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedMoveToHueAndSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("enhancedHue") - , (Integer) - commandArguments.get("saturation") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedMoveToHueAndSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedMoveToHueAndSaturation", colorControlenhancedMoveToHueAndSaturationInteractionInfo); - Map colorControlenhancedStepHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlenhancedStepHueCommandParams.put("stepMode",colorControlenhancedStepHuestepModeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlenhancedStepHueCommandParams.put("stepSize",colorControlenhancedStepHuestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlenhancedStepHueCommandParams.put("transitionTime",colorControlenhancedStepHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlenhancedStepHueCommandParams.put("optionsMask",colorControlenhancedStepHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlenhancedStepHueCommandParams.put("optionsOverride",colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlenhancedStepHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .enhancedStepHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlenhancedStepHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("enhancedStepHue", colorControlenhancedStepHueInteractionInfo); - Map colorControlmoveColorCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = new CommandParameterInfo("rateX", Integer.class); - colorControlmoveColorCommandParams.put("rateX",colorControlmoveColorrateXCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = new CommandParameterInfo("rateY", Integer.class); - colorControlmoveColorCommandParams.put("rateY",colorControlmoveColorrateYCommandParameterInfo); - - CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveColorCommandParams.put("optionsMask",colorControlmoveColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveColorCommandParams.put("optionsOverride",colorControlmoveColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveColorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveColor((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("rateX") - , (Integer) - commandArguments.get("rateY") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveColorCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveColor", colorControlmoveColorInteractionInfo); - Map colorControlmoveColorTemperatureCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("moveMode",colorControlmoveColorTemperaturemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("rate",colorControlmoveColorTemperaturerateCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("optionsMask",colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveColorTemperatureCommandParams.put("optionsOverride",colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveColorTemperatureInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveColorTemperature((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("colorTemperatureMinimum") - , (Integer) - commandArguments.get("colorTemperatureMaximum") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveColorTemperatureCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveColorTemperature", colorControlmoveColorTemperatureInteractionInfo); - Map colorControlmoveHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveHueCommandParams.put("moveMode",colorControlmoveHuemoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlmoveHueCommandParams.put("rate",colorControlmoveHuerateCommandParameterInfo); - - CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveHueCommandParams.put("optionsMask",colorControlmoveHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveHueCommandParams.put("optionsOverride",colorControlmoveHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveHue", colorControlmoveHueInteractionInfo); - Map colorControlmoveSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - colorControlmoveSaturationCommandParams.put("moveMode",colorControlmoveSaturationmoveModeCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - colorControlmoveSaturationCommandParams.put("rate",colorControlmoveSaturationrateCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveSaturationCommandParams.put("optionsMask",colorControlmoveSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveSaturationCommandParams.put("optionsOverride",colorControlmoveSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveSaturation", colorControlmoveSaturationInteractionInfo); - Map colorControlmoveToColorCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = new CommandParameterInfo("colorX", Integer.class); - colorControlmoveToColorCommandParams.put("colorX",colorControlmoveToColorcolorXCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = new CommandParameterInfo("colorY", Integer.class); - colorControlmoveToColorCommandParams.put("colorY",colorControlmoveToColorcolorYCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToColorCommandParams.put("transitionTime",colorControlmoveToColortransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToColorCommandParams.put("optionsMask",colorControlmoveToColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToColorCommandParams.put("optionsOverride",colorControlmoveToColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToColorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToColor((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("colorX") - , (Integer) - commandArguments.get("colorY") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToColorCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToColor", colorControlmoveToColorInteractionInfo); - Map colorControlmoveToColorTemperatureCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = new CommandParameterInfo("colorTemperature", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("colorTemperature",colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("transitionTime",colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("optionsMask",colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToColorTemperatureCommandParams.put("optionsOverride",colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToColorTemperature((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("colorTemperature") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToColorTemperatureCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToColorTemperature", colorControlmoveToColorTemperatureInteractionInfo); - Map colorControlmoveToHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); - colorControlmoveToHueCommandParams.put("hue",colorControlmoveToHuehueCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = new CommandParameterInfo("direction", Integer.class); - colorControlmoveToHueCommandParams.put("direction",colorControlmoveToHuedirectionCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToHueCommandParams.put("transitionTime",colorControlmoveToHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToHueCommandParams.put("optionsMask",colorControlmoveToHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToHueCommandParams.put("optionsOverride",colorControlmoveToHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("hue") - , (Integer) - commandArguments.get("direction") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToHue", colorControlmoveToHueInteractionInfo); - Map colorControlmoveToHueAndSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = new CommandParameterInfo("hue", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("hue",colorControlmoveToHueAndSaturationhueCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("saturation",colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("transitionTime",colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("optionsMask",colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToHueAndSaturationCommandParams.put("optionsOverride",colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToHueAndSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("hue") - , (Integer) - commandArguments.get("saturation") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToHueAndSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToHueAndSaturation", colorControlmoveToHueAndSaturationInteractionInfo); - Map colorControlmoveToSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = new CommandParameterInfo("saturation", Integer.class); - colorControlmoveToSaturationCommandParams.put("saturation",colorControlmoveToSaturationsaturationCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlmoveToSaturationCommandParams.put("transitionTime",colorControlmoveToSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlmoveToSaturationCommandParams.put("optionsMask",colorControlmoveToSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlmoveToSaturationCommandParams.put("optionsOverride",colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlmoveToSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .moveToSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("saturation") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlmoveToSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("moveToSaturation", colorControlmoveToSaturationInteractionInfo); - Map colorControlstepColorCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = new CommandParameterInfo("stepX", Integer.class); - colorControlstepColorCommandParams.put("stepX",colorControlstepColorstepXCommandParameterInfo); - - CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = new CommandParameterInfo("stepY", Integer.class); - colorControlstepColorCommandParams.put("stepY",colorControlstepColorstepYCommandParameterInfo); - - CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepColorCommandParams.put("transitionTime",colorControlstepColortransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepColorCommandParams.put("optionsMask",colorControlstepColoroptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepColorCommandParams.put("optionsOverride",colorControlstepColoroptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepColorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepColor((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepX") - , (Integer) - commandArguments.get("stepY") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepColorCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepColor", colorControlstepColorInteractionInfo); - Map colorControlstepColorTemperatureCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlstepColorTemperatureCommandParams.put("stepMode",colorControlstepColorTemperaturestepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlstepColorTemperatureCommandParams.put("stepSize",colorControlstepColorTemperaturestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepColorTemperatureCommandParams.put("transitionTime",colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMinimum", Integer.class); - colorControlstepColorTemperatureCommandParams.put("colorTemperatureMinimum",colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = new CommandParameterInfo("colorTemperatureMaximum", Integer.class); - colorControlstepColorTemperatureCommandParams.put("colorTemperatureMaximum",colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepColorTemperatureCommandParams.put("optionsMask",colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepColorTemperatureCommandParams.put("optionsOverride",colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepColorTemperatureInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepColorTemperature((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("colorTemperatureMinimum") - , (Integer) - commandArguments.get("colorTemperatureMaximum") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepColorTemperatureCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepColorTemperature", colorControlstepColorTemperatureInteractionInfo); - Map colorControlstepHueCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlstepHueCommandParams.put("stepMode",colorControlstepHuestepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlstepHueCommandParams.put("stepSize",colorControlstepHuestepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepHueCommandParams.put("transitionTime",colorControlstepHuetransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepHueCommandParams.put("optionsMask",colorControlstepHueoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepHueCommandParams.put("optionsOverride",colorControlstepHueoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepHueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepHue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepHueCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepHue", colorControlstepHueInteractionInfo); - Map colorControlstepSaturationCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - colorControlstepSaturationCommandParams.put("stepMode",colorControlstepSaturationstepModeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - colorControlstepSaturationCommandParams.put("stepSize",colorControlstepSaturationstepSizeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - colorControlstepSaturationCommandParams.put("transitionTime",colorControlstepSaturationtransitionTimeCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstepSaturationCommandParams.put("optionsMask",colorControlstepSaturationoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstepSaturationCommandParams.put("optionsOverride",colorControlstepSaturationoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstepSaturationInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stepSaturation((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstepSaturationCommandParams - ); - colorControlClusterInteractionInfoMap.put("stepSaturation", colorControlstepSaturationInteractionInfo); - Map colorControlstopMoveStepCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = new CommandParameterInfo("optionsMask", Integer.class); - colorControlstopMoveStepCommandParams.put("optionsMask",colorControlstopMoveStepoptionsMaskCommandParameterInfo); - - CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = new CommandParameterInfo("optionsOverride", Integer.class); - colorControlstopMoveStepCommandParams.put("optionsOverride",colorControlstopMoveStepoptionsOverrideCommandParameterInfo); - - InteractionInfo colorControlstopMoveStepInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster) - .stopMoveStep((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("optionsMask") - , (Integer) - commandArguments.get("optionsOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - colorControlstopMoveStepCommandParams - ); - colorControlClusterInteractionInfoMap.put("stopMoveStep", colorControlstopMoveStepInteractionInfo); - commandMap.put("colorControl", colorControlClusterInteractionInfoMap); - Map contentLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); - Map contentLauncherlaunchContentRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = new CommandParameterInfo("autoPlay", Boolean.class); - contentLauncherlaunchContentRequestCommandParams.put("autoPlay",contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); - - CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); - contentLauncherlaunchContentRequestCommandParams.put("data",contentLauncherlaunchContentRequestdataCommandParameterInfo); - - InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .launchContentRequest((ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback - , (Boolean) - commandArguments.get("autoPlay") - , (String) - commandArguments.get("data") - , (ArrayList) - commandArguments.get("search") - - ); - }, - () -> new DelegatedLaunchResponseCallback(), - contentLauncherlaunchContentRequestCommandParams - ); - contentLauncherClusterInteractionInfoMap.put("launchContentRequest", contentLauncherlaunchContentRequestInteractionInfo); - Map contentLauncherlaunchURLRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = new CommandParameterInfo("contentURL", String.class); - contentLauncherlaunchURLRequestCommandParams.put("contentURL",contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); - - CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = new CommandParameterInfo("displayString", String.class); - contentLauncherlaunchURLRequestCommandParams.put("displayString",contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); - - InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster) - .launchURLRequest((ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback - , (String) - commandArguments.get("contentURL") - , (String) - commandArguments.get("displayString") - , (ChipStructs.ContentLauncherClusterBrandingInformation) - commandArguments.get("brandingInformation") - - ); - }, - () -> new DelegatedLaunchResponseCallback(), - contentLauncherlaunchURLRequestCommandParams - ); - contentLauncherClusterInteractionInfoMap.put("launchURLRequest", contentLauncherlaunchURLRequestInteractionInfo); - commandMap.put("contentLauncher", contentLauncherClusterInteractionInfoMap); - Map descriptorClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("descriptor", descriptorClusterInteractionInfoMap); - Map diagnosticLogsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map diagnosticLogsretrieveLogsRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = new CommandParameterInfo("intent", Integer.class); - diagnosticLogsretrieveLogsRequestCommandParams.put("intent",diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); - - CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = new CommandParameterInfo("requestedProtocol", Integer.class); - diagnosticLogsretrieveLogsRequestCommandParams.put("requestedProtocol",diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); - - CommandParameterInfo diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = new CommandParameterInfo("transferFileDesignator", byte[].class); - diagnosticLogsretrieveLogsRequestCommandParams.put("transferFileDesignator",diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); - - InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster) - .retrieveLogsRequest((ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback) callback - , (Integer) - commandArguments.get("intent") - , (Integer) - commandArguments.get("requestedProtocol") - , (byte[]) - commandArguments.get("transferFileDesignator") - - ); - }, - () -> new DelegatedRetrieveLogsResponseCallback(), - diagnosticLogsretrieveLogsRequestCommandParams - ); - diagnosticLogsClusterInteractionInfoMap.put("retrieveLogsRequest", diagnosticLogsretrieveLogsRequestInteractionInfo); - commandMap.put("diagnosticLogs", diagnosticLogsClusterInteractionInfoMap); - Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); - Map doorLockclearCredentialCommandParams = new LinkedHashMap(); - InteractionInfo doorLockclearCredentialInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearCredential((DefaultClusterCallback) callback - , (ChipStructs.DoorLockClusterDlCredential) - commandArguments.get("credential") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearCredentialCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearCredential", doorLockclearCredentialInteractionInfo); - Map doorLockclearUserCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockclearUserCommandParams.put("userIndex",doorLockclearUseruserIndexCommandParameterInfo); - - InteractionInfo doorLockclearUserInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearUser((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("userIndex") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearUserCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearUser", doorLockclearUserInteractionInfo); - Map doorLockclearWeekDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); - doorLockclearWeekDayScheduleCommandParams.put("weekDayIndex",doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockclearWeekDayScheduleCommandParams.put("userIndex",doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearWeekDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("weekDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearWeekDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearWeekDaySchedule", doorLockclearWeekDayScheduleInteractionInfo); - Map doorLockclearYearDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); - doorLockclearYearDayScheduleCommandParams.put("yearDayIndex",doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockclearYearDayScheduleCommandParams.put("userIndex",doorLockclearYearDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockclearYearDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .clearYearDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("yearDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockclearYearDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("clearYearDaySchedule", doorLockclearYearDayScheduleInteractionInfo); - Map doorLockgetCredentialStatusCommandParams = new LinkedHashMap(); - InteractionInfo doorLockgetCredentialStatusInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getCredentialStatus((ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback - , (ChipStructs.DoorLockClusterDlCredential) - commandArguments.get("credential") - - ); - }, - () -> new DelegatedGetCredentialStatusResponseCallback(), - doorLockgetCredentialStatusCommandParams - ); - doorLockClusterInteractionInfoMap.put("getCredentialStatus", doorLockgetCredentialStatusInteractionInfo); - Map doorLockgetUserCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockgetUserCommandParams.put("userIndex",doorLockgetUseruserIndexCommandParameterInfo); - - InteractionInfo doorLockgetUserInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getUser((ChipClusters.DoorLockCluster.GetUserResponseCallback) callback - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedGetUserResponseCallback(), - doorLockgetUserCommandParams - ); - doorLockClusterInteractionInfoMap.put("getUser", doorLockgetUserInteractionInfo); - Map doorLockgetWeekDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); - doorLockgetWeekDayScheduleCommandParams.put("weekDayIndex",doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockgetWeekDayScheduleCommandParams.put("userIndex",doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getWeekDaySchedule((ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback) callback - , (Integer) - commandArguments.get("weekDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedGetWeekDayScheduleResponseCallback(), - doorLockgetWeekDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("getWeekDaySchedule", doorLockgetWeekDayScheduleInteractionInfo); - Map doorLockgetYearDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); - doorLockgetYearDayScheduleCommandParams.put("yearDayIndex",doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLockgetYearDayScheduleCommandParams.put("userIndex",doorLockgetYearDayScheduleuserIndexCommandParameterInfo); - - InteractionInfo doorLockgetYearDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .getYearDaySchedule((ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback) callback - , (Integer) - commandArguments.get("yearDayIndex") - , (Integer) - commandArguments.get("userIndex") - - ); - }, - () -> new DelegatedGetYearDayScheduleResponseCallback(), - doorLockgetYearDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("getYearDaySchedule", doorLockgetYearDayScheduleInteractionInfo); - Map doorLocklockDoorCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); - doorLocklockDoorCommandParams.put("pinCode",doorLocklockDoorpinCodeCommandParameterInfo); - - InteractionInfo doorLocklockDoorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .lockDoor((DefaultClusterCallback) callback - , (Optional) - commandArguments.get("pinCode") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocklockDoorCommandParams - ); - doorLockClusterInteractionInfoMap.put("lockDoor", doorLocklockDoorInteractionInfo); - Map doorLocksetCredentialCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); - doorLocksetCredentialCommandParams.put("operationType",doorLocksetCredentialoperationTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = new CommandParameterInfo("credentialData", byte[].class); - doorLocksetCredentialCommandParams.put("credentialData",doorLocksetCredentialcredentialDataCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetCredentialCommandParams.put("userIndex",doorLocksetCredentialuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); - doorLocksetCredentialCommandParams.put("userStatus",doorLocksetCredentialuserStatusCommandParameterInfo); - - CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); - doorLocksetCredentialCommandParams.put("userType",doorLocksetCredentialuserTypeCommandParameterInfo); - - InteractionInfo doorLocksetCredentialInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setCredential((ChipClusters.DoorLockCluster.SetCredentialResponseCallback) callback - , (Integer) - commandArguments.get("operationType") - , (ChipStructs.DoorLockClusterDlCredential) - commandArguments.get("credential") - , (byte[]) - commandArguments.get("credentialData") - , (Integer) - commandArguments.get("userIndex") - , (Integer) - commandArguments.get("userStatus") - , (Integer) - commandArguments.get("userType") - , 10000 - ); - }, - () -> new DelegatedSetCredentialResponseCallback(), - doorLocksetCredentialCommandParams - ); - doorLockClusterInteractionInfoMap.put("setCredential", doorLocksetCredentialInteractionInfo); - Map doorLocksetUserCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = new CommandParameterInfo("operationType", Integer.class); - doorLocksetUserCommandParams.put("operationType",doorLocksetUseroperationTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetUserCommandParams.put("userIndex",doorLocksetUseruserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = new CommandParameterInfo("userName", String.class); - doorLocksetUserCommandParams.put("userName",doorLocksetUseruserNameCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = new CommandParameterInfo("userUniqueId", Long.class); - doorLocksetUserCommandParams.put("userUniqueId",doorLocksetUseruserUniqueIdCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = new CommandParameterInfo("userStatus", Integer.class); - doorLocksetUserCommandParams.put("userStatus",doorLocksetUseruserStatusCommandParameterInfo); - - CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = new CommandParameterInfo("userType", Integer.class); - doorLocksetUserCommandParams.put("userType",doorLocksetUseruserTypeCommandParameterInfo); - - CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = new CommandParameterInfo("credentialRule", Integer.class); - doorLocksetUserCommandParams.put("credentialRule",doorLocksetUsercredentialRuleCommandParameterInfo); - - InteractionInfo doorLocksetUserInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setUser((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("operationType") - , (Integer) - commandArguments.get("userIndex") - , (String) - commandArguments.get("userName") - , (Long) - commandArguments.get("userUniqueId") - , (Integer) - commandArguments.get("userStatus") - , (Integer) - commandArguments.get("userType") - , (Integer) - commandArguments.get("credentialRule") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetUserCommandParams - ); - doorLockClusterInteractionInfoMap.put("setUser", doorLocksetUserInteractionInfo); - Map doorLocksetWeekDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = new CommandParameterInfo("weekDayIndex", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("weekDayIndex",doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("userIndex",doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = new CommandParameterInfo("daysMask", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("daysMask",doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = new CommandParameterInfo("startHour", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("startHour",doorLocksetWeekDaySchedulestartHourCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = new CommandParameterInfo("startMinute", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("startMinute",doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = new CommandParameterInfo("endHour", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("endHour",doorLocksetWeekDayScheduleendHourCommandParameterInfo); - - CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = new CommandParameterInfo("endMinute", Integer.class); - doorLocksetWeekDayScheduleCommandParams.put("endMinute",doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); - - InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setWeekDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("weekDayIndex") - , (Integer) - commandArguments.get("userIndex") - , (Integer) - commandArguments.get("daysMask") - , (Integer) - commandArguments.get("startHour") - , (Integer) - commandArguments.get("startMinute") - , (Integer) - commandArguments.get("endHour") - , (Integer) - commandArguments.get("endMinute") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetWeekDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("setWeekDaySchedule", doorLocksetWeekDayScheduleInteractionInfo); - Map doorLocksetYearDayScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = new CommandParameterInfo("yearDayIndex", Integer.class); - doorLocksetYearDayScheduleCommandParams.put("yearDayIndex",doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = new CommandParameterInfo("userIndex", Integer.class); - doorLocksetYearDayScheduleCommandParams.put("userIndex",doorLocksetYearDayScheduleuserIndexCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = new CommandParameterInfo("localStartTime", Long.class); - doorLocksetYearDayScheduleCommandParams.put("localStartTime",doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); - - CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = new CommandParameterInfo("localEndTime", Long.class); - doorLocksetYearDayScheduleCommandParams.put("localEndTime",doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); - - InteractionInfo doorLocksetYearDayScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .setYearDaySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("yearDayIndex") - , (Integer) - commandArguments.get("userIndex") - , (Long) - commandArguments.get("localStartTime") - , (Long) - commandArguments.get("localEndTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLocksetYearDayScheduleCommandParams - ); - doorLockClusterInteractionInfoMap.put("setYearDaySchedule", doorLocksetYearDayScheduleInteractionInfo); - Map doorLockunlockDoorCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); - doorLockunlockDoorCommandParams.put("pinCode",doorLockunlockDoorpinCodeCommandParameterInfo); - - InteractionInfo doorLockunlockDoorInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .unlockDoor((DefaultClusterCallback) callback - , (Optional) - commandArguments.get("pinCode") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockunlockDoorCommandParams - ); - doorLockClusterInteractionInfoMap.put("unlockDoor", doorLockunlockDoorInteractionInfo); - Map doorLockunlockWithTimeoutCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = new CommandParameterInfo("timeout", Integer.class); - doorLockunlockWithTimeoutCommandParams.put("timeout",doorLockunlockWithTimeouttimeoutCommandParameterInfo); - - CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = new CommandParameterInfo("pinCode", Optional.class); - doorLockunlockWithTimeoutCommandParams.put("pinCode",doorLockunlockWithTimeoutpinCodeCommandParameterInfo); - - InteractionInfo doorLockunlockWithTimeoutInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster) - .unlockWithTimeout((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("timeout") - , (Optional) - commandArguments.get("pinCode") - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - doorLockunlockWithTimeoutCommandParams - ); - doorLockClusterInteractionInfoMap.put("unlockWithTimeout", doorLockunlockWithTimeoutInteractionInfo); - commandMap.put("doorLock", doorLockClusterInteractionInfoMap); - Map electricalMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("electricalMeasurement", electricalMeasurementClusterInteractionInfoMap); - Map ethernetNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map ethernetNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); - InteractionInfo ethernetNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - ethernetNetworkDiagnosticsresetCountsCommandParams - ); - ethernetNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", ethernetNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); - Map fixedLabelClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("fixedLabel", fixedLabelClusterInteractionInfoMap); - Map flowMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("flowMeasurement", flowMeasurementClusterInteractionInfoMap); - Map generalCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); - Map generalCommissioningarmFailSafeCommandParams = new LinkedHashMap(); - CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = new CommandParameterInfo("expiryLengthSeconds", Integer.class); - generalCommissioningarmFailSafeCommandParams.put("expiryLengthSeconds",generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); - - CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - generalCommissioningarmFailSafeCommandParams.put("breadcrumb",generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); - - CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); - generalCommissioningarmFailSafeCommandParams.put("timeoutMs",generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); - - InteractionInfo generalCommissioningarmFailSafeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .armFailSafe((ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback) callback - , (Integer) - commandArguments.get("expiryLengthSeconds") - , (Long) - commandArguments.get("breadcrumb") - , (Long) - commandArguments.get("timeoutMs") - - ); - }, - () -> new DelegatedArmFailSafeResponseCallback(), - generalCommissioningarmFailSafeCommandParams - ); - generalCommissioningClusterInteractionInfoMap.put("armFailSafe", generalCommissioningarmFailSafeInteractionInfo); - Map generalCommissioningcommissioningCompleteCommandParams = new LinkedHashMap(); - InteractionInfo generalCommissioningcommissioningCompleteInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .commissioningComplete((ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback) callback - - ); - }, - () -> new DelegatedCommissioningCompleteResponseCallback(), - generalCommissioningcommissioningCompleteCommandParams - ); - generalCommissioningClusterInteractionInfoMap.put("commissioningComplete", generalCommissioningcommissioningCompleteInteractionInfo); - Map generalCommissioningsetRegulatoryConfigCommandParams = new LinkedHashMap(); - CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = new CommandParameterInfo("location", Integer.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("location",generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = new CommandParameterInfo("countryCode", String.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("countryCode",generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("breadcrumb",generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); - - CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = new CommandParameterInfo("timeoutMs", Long.class); - generalCommissioningsetRegulatoryConfigCommandParams.put("timeoutMs",generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); - - InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster) - .setRegulatoryConfig((ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback) callback - , (Integer) - commandArguments.get("location") - , (String) - commandArguments.get("countryCode") - , (Long) - commandArguments.get("breadcrumb") - , (Long) - commandArguments.get("timeoutMs") - - ); - }, - () -> new DelegatedSetRegulatoryConfigResponseCallback(), - generalCommissioningsetRegulatoryConfigCommandParams - ); - generalCommissioningClusterInteractionInfoMap.put("setRegulatoryConfig", generalCommissioningsetRegulatoryConfigInteractionInfo); - commandMap.put("generalCommissioning", generalCommissioningClusterInteractionInfoMap); - Map generalDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("generalDiagnostics", generalDiagnosticsClusterInteractionInfoMap); - Map groupKeyManagementClusterInteractionInfoMap = new LinkedHashMap<>(); - Map groupKeyManagementkeySetReadCommandParams = new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); - groupKeyManagementkeySetReadCommandParams.put("groupKeySetID",groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetReadInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetRead((ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback - , (Integer) - commandArguments.get("groupKeySetID") - - ); - }, - () -> new DelegatedKeySetReadResponseCallback(), - groupKeyManagementkeySetReadCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetRead", groupKeyManagementkeySetReadInteractionInfo); - Map groupKeyManagementkeySetReadAllIndicesCommandParams = new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = new CommandParameterInfo("groupKeySetIDs", ArrayList.class); - groupKeyManagementkeySetReadAllIndicesCommandParams.put("groupKeySetIDs",groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetReadAllIndices((ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) callback - , (ArrayList) - commandArguments.get("groupKeySetIDs") - - ); - }, - () -> new DelegatedKeySetReadAllIndicesResponseCallback(), - groupKeyManagementkeySetReadAllIndicesCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetReadAllIndices", groupKeyManagementkeySetReadAllIndicesInteractionInfo); - Map groupKeyManagementkeySetRemoveCommandParams = new LinkedHashMap(); - CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = new CommandParameterInfo("groupKeySetID", Integer.class); - groupKeyManagementkeySetRemoveCommandParams.put("groupKeySetID",groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); - - InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetRemove((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("groupKeySetID") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupKeyManagementkeySetRemoveCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetRemove", groupKeyManagementkeySetRemoveInteractionInfo); - Map groupKeyManagementkeySetWriteCommandParams = new LinkedHashMap(); - InteractionInfo groupKeyManagementkeySetWriteInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster) - .keySetWrite((DefaultClusterCallback) callback - , (ChipStructs.GroupKeyManagementClusterGroupKeySet) - commandArguments.get("groupKeySet") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupKeyManagementkeySetWriteCommandParams - ); - groupKeyManagementClusterInteractionInfoMap.put("keySetWrite", groupKeyManagementkeySetWriteInteractionInfo); - commandMap.put("groupKeyManagement", groupKeyManagementClusterInteractionInfoMap); - Map groupsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map groupsaddGroupCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsaddGroupCommandParams.put("groupId",groupsaddGroupgroupIdCommandParameterInfo); - - CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); - groupsaddGroupCommandParams.put("groupName",groupsaddGroupgroupNameCommandParameterInfo); - - InteractionInfo groupsaddGroupInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .addGroup((ChipClusters.GroupsCluster.AddGroupResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (String) - commandArguments.get("groupName") - - ); - }, - () -> new DelegatedAddGroupResponseCallback(), - groupsaddGroupCommandParams - ); - groupsClusterInteractionInfoMap.put("addGroup", groupsaddGroupInteractionInfo); - Map groupsaddGroupIfIdentifyingCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsaddGroupIfIdentifyingCommandParams.put("groupId",groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); - - CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = new CommandParameterInfo("groupName", String.class); - groupsaddGroupIfIdentifyingCommandParams.put("groupName",groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); - - InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .addGroupIfIdentifying((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("groupId") - , (String) - commandArguments.get("groupName") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupsaddGroupIfIdentifyingCommandParams - ); - groupsClusterInteractionInfoMap.put("addGroupIfIdentifying", groupsaddGroupIfIdentifyingInteractionInfo); - Map groupsgetGroupMembershipCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = new CommandParameterInfo("groupList", ArrayList.class); - groupsgetGroupMembershipCommandParams.put("groupList",groupsgetGroupMembershipgroupListCommandParameterInfo); - - InteractionInfo groupsgetGroupMembershipInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .getGroupMembership((ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback - , (ArrayList) - commandArguments.get("groupList") - - ); - }, - () -> new DelegatedGetGroupMembershipResponseCallback(), - groupsgetGroupMembershipCommandParams - ); - groupsClusterInteractionInfoMap.put("getGroupMembership", groupsgetGroupMembershipInteractionInfo); - Map groupsremoveAllGroupsCommandParams = new LinkedHashMap(); - InteractionInfo groupsremoveAllGroupsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .removeAllGroups((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - groupsremoveAllGroupsCommandParams - ); - groupsClusterInteractionInfoMap.put("removeAllGroups", groupsremoveAllGroupsInteractionInfo); - Map groupsremoveGroupCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsremoveGroupCommandParams.put("groupId",groupsremoveGroupgroupIdCommandParameterInfo); - - InteractionInfo groupsremoveGroupInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .removeGroup((ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedRemoveGroupResponseCallback(), - groupsremoveGroupCommandParams - ); - groupsClusterInteractionInfoMap.put("removeGroup", groupsremoveGroupInteractionInfo); - Map groupsviewGroupCommandParams = new LinkedHashMap(); - CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - groupsviewGroupCommandParams.put("groupId",groupsviewGroupgroupIdCommandParameterInfo); - - InteractionInfo groupsviewGroupInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster) - .viewGroup((ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedViewGroupResponseCallback(), - groupsviewGroupCommandParams - ); - groupsClusterInteractionInfoMap.put("viewGroup", groupsviewGroupInteractionInfo); - commandMap.put("groups", groupsClusterInteractionInfoMap); - Map identifyClusterInteractionInfoMap = new LinkedHashMap<>(); - Map identifyidentifyCommandParams = new LinkedHashMap(); - CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("identifyTime", Integer.class); - identifyidentifyCommandParams.put("identifyTime",identifyidentifyidentifyTimeCommandParameterInfo); - - InteractionInfo identifyidentifyInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .identify((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("identifyTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - identifyidentifyCommandParams - ); - identifyClusterInteractionInfoMap.put("identify", identifyidentifyInteractionInfo); - Map identifyidentifyQueryCommandParams = new LinkedHashMap(); - InteractionInfo identifyidentifyQueryInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .identifyQuery((ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback - - ); - }, - () -> new DelegatedIdentifyQueryResponseCallback(), - identifyidentifyQueryCommandParams - ); - identifyClusterInteractionInfoMap.put("identifyQuery", identifyidentifyQueryInteractionInfo); - Map identifytriggerEffectCommandParams = new LinkedHashMap(); - CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = new CommandParameterInfo("effectIdentifier", Integer.class); - identifytriggerEffectCommandParams.put("effectIdentifier",identifytriggerEffecteffectIdentifierCommandParameterInfo); - - CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); - identifytriggerEffectCommandParams.put("effectVariant",identifytriggerEffecteffectVariantCommandParameterInfo); - - InteractionInfo identifytriggerEffectInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster) - .triggerEffect((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("effectIdentifier") - , (Integer) - commandArguments.get("effectVariant") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - identifytriggerEffectCommandParams - ); - identifyClusterInteractionInfoMap.put("triggerEffect", identifytriggerEffectInteractionInfo); - commandMap.put("identify", identifyClusterInteractionInfoMap); - Map illuminanceMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInteractionInfoMap); - Map keypadInputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map keypadInputsendKeyRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = new CommandParameterInfo("keyCode", Integer.class); - keypadInputsendKeyRequestCommandParams.put("keyCode",keypadInputsendKeyRequestkeyCodeCommandParameterInfo); - - InteractionInfo keypadInputsendKeyRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster) - .sendKeyRequest((ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback - , (Integer) - commandArguments.get("keyCode") - - ); - }, - () -> new DelegatedSendKeyResponseCallback(), - keypadInputsendKeyRequestCommandParams - ); - keypadInputClusterInteractionInfoMap.put("sendKeyRequest", keypadInputsendKeyRequestInteractionInfo); - commandMap.put("keypadInput", keypadInputClusterInteractionInfoMap); - Map levelControlClusterInteractionInfoMap = new LinkedHashMap<>(); - Map levelControlmoveCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - levelControlmoveCommandParams.put("moveMode",levelControlmovemoveModeCommandParameterInfo); - - CommandParameterInfo levelControlmoverateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - levelControlmoveCommandParams.put("rate",levelControlmoverateCommandParameterInfo); - - CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlmoveCommandParams.put("optionMask",levelControlmoveoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlmoveCommandParams.put("optionOverride",levelControlmoveoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlmoveInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .move((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveCommandParams - ); - levelControlClusterInteractionInfoMap.put("move", levelControlmoveInteractionInfo); - Map levelControlmoveToLevelCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); - levelControlmoveToLevelCommandParams.put("level",levelControlmoveToLevellevelCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlmoveToLevelCommandParams.put("transitionTime",levelControlmoveToLeveltransitionTimeCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlmoveToLevelCommandParams.put("optionMask",levelControlmoveToLeveloptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlmoveToLevelCommandParams.put("optionOverride",levelControlmoveToLeveloptionOverrideCommandParameterInfo); - - InteractionInfo levelControlmoveToLevelInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveToLevel((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("level") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveToLevelCommandParams - ); - levelControlClusterInteractionInfoMap.put("moveToLevel", levelControlmoveToLevelInteractionInfo); - Map levelControlmoveToLevelWithOnOffCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = new CommandParameterInfo("level", Integer.class); - levelControlmoveToLevelWithOnOffCommandParams.put("level",levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); - - CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlmoveToLevelWithOnOffCommandParams.put("transitionTime",levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); - - InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveToLevelWithOnOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("level") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveToLevelWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffInteractionInfo); - Map levelControlmoveWithOnOffCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = new CommandParameterInfo("moveMode", Integer.class); - levelControlmoveWithOnOffCommandParams.put("moveMode",levelControlmoveWithOnOffmoveModeCommandParameterInfo); - - CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = new CommandParameterInfo("rate", Integer.class); - levelControlmoveWithOnOffCommandParams.put("rate",levelControlmoveWithOnOffrateCommandParameterInfo); - - InteractionInfo levelControlmoveWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .moveWithOnOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("moveMode") - , (Integer) - commandArguments.get("rate") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlmoveWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("moveWithOnOff", levelControlmoveWithOnOffInteractionInfo); - Map levelControlstepCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlstepstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - levelControlstepCommandParams.put("stepMode",levelControlstepstepModeCommandParameterInfo); - - CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - levelControlstepCommandParams.put("stepSize",levelControlstepstepSizeCommandParameterInfo); - - CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlstepCommandParams.put("transitionTime",levelControlsteptransitionTimeCommandParameterInfo); - - CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlstepCommandParams.put("optionMask",levelControlstepoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlstepCommandParams.put("optionOverride",levelControlstepoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlstepInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .step((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstepCommandParams - ); - levelControlClusterInteractionInfoMap.put("step", levelControlstepInteractionInfo); - Map levelControlstepWithOnOffCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = new CommandParameterInfo("stepMode", Integer.class); - levelControlstepWithOnOffCommandParams.put("stepMode",levelControlstepWithOnOffstepModeCommandParameterInfo); - - CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = new CommandParameterInfo("stepSize", Integer.class); - levelControlstepWithOnOffCommandParams.put("stepSize",levelControlstepWithOnOffstepSizeCommandParameterInfo); - - CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - levelControlstepWithOnOffCommandParams.put("transitionTime",levelControlstepWithOnOfftransitionTimeCommandParameterInfo); - - InteractionInfo levelControlstepWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stepWithOnOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("stepMode") - , (Integer) - commandArguments.get("stepSize") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstepWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("stepWithOnOff", levelControlstepWithOnOffInteractionInfo); - Map levelControlstopCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = new CommandParameterInfo("optionMask", Integer.class); - levelControlstopCommandParams.put("optionMask",levelControlstopoptionMaskCommandParameterInfo); - - CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = new CommandParameterInfo("optionOverride", Integer.class); - levelControlstopCommandParams.put("optionOverride",levelControlstopoptionOverrideCommandParameterInfo); - - InteractionInfo levelControlstopInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stop((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("optionMask") - , (Integer) - commandArguments.get("optionOverride") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstopCommandParams - ); - levelControlClusterInteractionInfoMap.put("stop", levelControlstopInteractionInfo); - Map levelControlstopWithOnOffCommandParams = new LinkedHashMap(); - InteractionInfo levelControlstopWithOnOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster) - .stopWithOnOff((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - levelControlstopWithOnOffCommandParams - ); - levelControlClusterInteractionInfoMap.put("stopWithOnOff", levelControlstopWithOnOffInteractionInfo); - commandMap.put("levelControl", levelControlClusterInteractionInfoMap); - Map localizationConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("localizationConfiguration", localizationConfigurationClusterInteractionInfoMap); - Map lowPowerClusterInteractionInfoMap = new LinkedHashMap<>(); - Map lowPowersleepCommandParams = new LinkedHashMap(); - InteractionInfo lowPowersleepInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster) - .sleep((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - lowPowersleepCommandParams - ); - lowPowerClusterInteractionInfoMap.put("sleep", lowPowersleepInteractionInfo); - commandMap.put("lowPower", lowPowerClusterInteractionInfoMap); - Map mediaInputClusterInteractionInfoMap = new LinkedHashMap<>(); - Map mediaInputhideInputStatusRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaInputhideInputStatusRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .hideInputStatusRequest((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputhideInputStatusRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("hideInputStatusRequest", mediaInputhideInputStatusRequestInteractionInfo); - Map mediaInputrenameInputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - mediaInputrenameInputRequestCommandParams.put("index",mediaInputrenameInputRequestindexCommandParameterInfo); - - CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = new CommandParameterInfo("name", String.class); - mediaInputrenameInputRequestCommandParams.put("name",mediaInputrenameInputRequestnameCommandParameterInfo); - - InteractionInfo mediaInputrenameInputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .renameInputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - , (String) - commandArguments.get("name") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputrenameInputRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("renameInputRequest", mediaInputrenameInputRequestInteractionInfo); - Map mediaInputselectInputRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = new CommandParameterInfo("index", Integer.class); - mediaInputselectInputRequestCommandParams.put("index",mediaInputselectInputRequestindexCommandParameterInfo); - - InteractionInfo mediaInputselectInputRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .selectInputRequest((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("index") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputselectInputRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("selectInputRequest", mediaInputselectInputRequestInteractionInfo); - Map mediaInputshowInputStatusRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaInputshowInputStatusRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster) - .showInputStatusRequest((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - mediaInputshowInputStatusRequestCommandParams - ); - mediaInputClusterInteractionInfoMap.put("showInputStatusRequest", mediaInputshowInputStatusRequestInteractionInfo); - commandMap.put("mediaInput", mediaInputClusterInteractionInfoMap); - Map mediaPlaybackClusterInteractionInfoMap = new LinkedHashMap<>(); - Map mediaPlaybackfastForwardRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackfastForwardRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .fastForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackfastForwardRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("fastForwardRequest", mediaPlaybackfastForwardRequestInteractionInfo); - Map mediaPlaybacknextRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybacknextRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .nextRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybacknextRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("nextRequest", mediaPlaybacknextRequestInteractionInfo); - Map mediaPlaybackpauseRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackpauseRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .pauseRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackpauseRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("pauseRequest", mediaPlaybackpauseRequestInteractionInfo); - Map mediaPlaybackplayRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackplayRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .playRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackplayRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("playRequest", mediaPlaybackplayRequestInteractionInfo); - Map mediaPlaybackpreviousRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackpreviousRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .previousRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackpreviousRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("previousRequest", mediaPlaybackpreviousRequestInteractionInfo); - Map mediaPlaybackrewindRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackrewindRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .rewindRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackrewindRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("rewindRequest", mediaPlaybackrewindRequestInteractionInfo); - Map mediaPlaybackseekRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = new CommandParameterInfo("position", Long.class); - mediaPlaybackseekRequestCommandParams.put("position",mediaPlaybackseekRequestpositionCommandParameterInfo); - - InteractionInfo mediaPlaybackseekRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .seekRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - , (Long) - commandArguments.get("position") - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackseekRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("seekRequest", mediaPlaybackseekRequestInteractionInfo); - Map mediaPlaybackskipBackwardRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); - mediaPlaybackskipBackwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); - - InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .skipBackwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - , (Long) - commandArguments.get("deltaPositionMilliseconds") - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackskipBackwardRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("skipBackwardRequest", mediaPlaybackskipBackwardRequestInteractionInfo); - Map mediaPlaybackskipForwardRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = new CommandParameterInfo("deltaPositionMilliseconds", Long.class); - mediaPlaybackskipForwardRequestCommandParams.put("deltaPositionMilliseconds",mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); - - InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .skipForwardRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - , (Long) - commandArguments.get("deltaPositionMilliseconds") - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackskipForwardRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("skipForwardRequest", mediaPlaybackskipForwardRequestInteractionInfo); - Map mediaPlaybackstartOverRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackstartOverRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .startOverRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackstartOverRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("startOverRequest", mediaPlaybackstartOverRequestInteractionInfo); - Map mediaPlaybackstopRequestCommandParams = new LinkedHashMap(); - InteractionInfo mediaPlaybackstopRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster) - .stopRequest((ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback - - ); - }, - () -> new DelegatedPlaybackResponseCallback(), - mediaPlaybackstopRequestCommandParams - ); - mediaPlaybackClusterInteractionInfoMap.put("stopRequest", mediaPlaybackstopRequestInteractionInfo); - commandMap.put("mediaPlayback", mediaPlaybackClusterInteractionInfoMap); - Map modeSelectClusterInteractionInfoMap = new LinkedHashMap<>(); - Map modeSelectchangeToModeCommandParams = new LinkedHashMap(); - CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = new CommandParameterInfo("newMode", Integer.class); - modeSelectchangeToModeCommandParams.put("newMode",modeSelectchangeToModenewModeCommandParameterInfo); - - InteractionInfo modeSelectchangeToModeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster) - .changeToMode((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("newMode") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - modeSelectchangeToModeCommandParams - ); - modeSelectClusterInteractionInfoMap.put("changeToMode", modeSelectchangeToModeInteractionInfo); - commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); - Map networkCommissioningClusterInteractionInfoMap = new LinkedHashMap<>(); - Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = new CommandParameterInfo("operationalDataset", byte[].class); - networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("operationalDataset",networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningaddOrUpdateThreadNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .addOrUpdateThreadNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("operationalDataset") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningaddOrUpdateThreadNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("addOrUpdateThreadNetwork", networkCommissioningaddOrUpdateThreadNetworkInteractionInfo); - Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("ssid",networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = new CommandParameterInfo("credentials", byte[].class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("credentials",networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); - - CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put("breadcrumb",networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .addOrUpdateWiFiNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("ssid") - , (byte[]) - commandArguments.get("credentials") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningaddOrUpdateWiFiNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("addOrUpdateWiFiNetwork", networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo); - Map networkCommissioningconnectNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); - networkCommissioningconnectNetworkCommandParams.put("networkID",networkCommissioningconnectNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningconnectNetworkCommandParams.put("breadcrumb",networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningconnectNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .connectNetwork((ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback) callback - , (byte[]) - commandArguments.get("networkID") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedConnectNetworkResponseCallback(), - networkCommissioningconnectNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("connectNetwork", networkCommissioningconnectNetworkInteractionInfo); - Map networkCommissioningremoveNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); - networkCommissioningremoveNetworkCommandParams.put("networkID",networkCommissioningremoveNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningremoveNetworkCommandParams.put("breadcrumb",networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningremoveNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .removeNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("networkID") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningremoveNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("removeNetwork", networkCommissioningremoveNetworkInteractionInfo); - Map networkCommissioningreorderNetworkCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = new CommandParameterInfo("networkID", byte[].class); - networkCommissioningreorderNetworkCommandParams.put("networkID",networkCommissioningreorderNetworknetworkIDCommandParameterInfo); - - CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = new CommandParameterInfo("networkIndex", Integer.class); - networkCommissioningreorderNetworkCommandParams.put("networkIndex",networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); - - CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningreorderNetworkCommandParams.put("breadcrumb",networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningreorderNetworkInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .reorderNetwork((ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) callback - , (byte[]) - commandArguments.get("networkID") - , (Integer) - commandArguments.get("networkIndex") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedNetworkConfigResponseCallback(), - networkCommissioningreorderNetworkCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("reorderNetwork", networkCommissioningreorderNetworkInteractionInfo); - Map networkCommissioningscanNetworksCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = new CommandParameterInfo("ssid", byte[].class); - networkCommissioningscanNetworksCommandParams.put("ssid",networkCommissioningscanNetworksssidCommandParameterInfo); - - CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = new CommandParameterInfo("breadcrumb", Long.class); - networkCommissioningscanNetworksCommandParams.put("breadcrumb",networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); - - InteractionInfo networkCommissioningscanNetworksInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster) - .scanNetworks((ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback) callback - , (byte[]) - commandArguments.get("ssid") - , (Long) - commandArguments.get("breadcrumb") - - ); - }, - () -> new DelegatedScanNetworksResponseCallback(), - networkCommissioningscanNetworksCommandParams - ); - networkCommissioningClusterInteractionInfoMap.put("scanNetworks", networkCommissioningscanNetworksInteractionInfo); - commandMap.put("networkCommissioning", networkCommissioningClusterInteractionInfoMap); - Map otaSoftwareUpdateProviderClusterInteractionInfoMap = new LinkedHashMap<>(); - Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("updateToken",otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = new CommandParameterInfo("newVersion", Long.class); - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put("newVersion",otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .applyUpdateRequest((ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback) callback - , (byte[]) - commandArguments.get("updateToken") - , (Long) - commandArguments.get("newVersion") - - ); - }, - () -> new DelegatedApplyUpdateResponseCallback(), - otaSoftwareUpdateProviderapplyUpdateRequestCommandParams - ); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put("applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo); - Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = new CommandParameterInfo("updateToken", byte[].class); - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("updateToken",otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put("softwareVersion",otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .notifyUpdateApplied((DefaultClusterCallback) callback - , (byte[]) - commandArguments.get("updateToken") - , (Long) - commandArguments.get("softwareVersion") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams - ); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put("notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo); - Map otaSoftwareUpdateProviderqueryImageCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("vendorId",otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = new CommandParameterInfo("productId", Integer.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("productId",otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = new CommandParameterInfo("softwareVersion", Long.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("softwareVersion",otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = new CommandParameterInfo("protocolsSupported", ArrayList.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("protocolsSupported",otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = new CommandParameterInfo("hardwareVersion", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("hardwareVersion",otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = new CommandParameterInfo("location", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("location",otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = new CommandParameterInfo("requestorCanConsent", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("requestorCanConsent",otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = new CommandParameterInfo("metadataForProvider", Optional.class); - otaSoftwareUpdateProviderqueryImageCommandParams.put("metadataForProvider",otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) - .queryImage((ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback) callback - , (Integer) - commandArguments.get("vendorId") - , (Integer) - commandArguments.get("productId") - , (Long) - commandArguments.get("softwareVersion") - , (ArrayList) - commandArguments.get("protocolsSupported") - , (Optional) - commandArguments.get("hardwareVersion") - , (Optional) - commandArguments.get("location") - , (Optional) - commandArguments.get("requestorCanConsent") - , (Optional) - commandArguments.get("metadataForProvider") - - ); - }, - () -> new DelegatedQueryImageResponseCallback(), - otaSoftwareUpdateProviderqueryImageCommandParams - ); - otaSoftwareUpdateProviderClusterInteractionInfoMap.put("queryImage", otaSoftwareUpdateProviderqueryImageInteractionInfo); - commandMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInteractionInfoMap); - Map otaSoftwareUpdateRequestorClusterInteractionInfoMap = new LinkedHashMap<>(); - Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = new LinkedHashMap(); - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = new CommandParameterInfo("providerNodeId", Long.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("providerNodeId",otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = new CommandParameterInfo("vendorId", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("vendorId",otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = new CommandParameterInfo("announcementReason", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("announcementReason",otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = new CommandParameterInfo("metadataForNode", Optional.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("metadataForNode",otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); - - CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = new CommandParameterInfo("endpoint", Integer.class); - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put("endpoint",otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); - - InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) - .announceOtaProvider((DefaultClusterCallback) callback - , (Long) - commandArguments.get("providerNodeId") - , (Integer) - commandArguments.get("vendorId") - , (Integer) - commandArguments.get("announcementReason") - , (Optional) - commandArguments.get("metadataForNode") - , (Integer) - commandArguments.get("endpoint") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - otaSoftwareUpdateRequestorannounceOtaProviderCommandParams - ); - otaSoftwareUpdateRequestorClusterInteractionInfoMap.put("announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo); - commandMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInteractionInfoMap); - Map occupancySensingClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("occupancySensing", occupancySensingClusterInteractionInfoMap); - Map onOffClusterInteractionInfoMap = new LinkedHashMap<>(); - Map onOffoffCommandParams = new LinkedHashMap(); - InteractionInfo onOffoffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .off((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffoffCommandParams - ); - onOffClusterInteractionInfoMap.put("off", onOffoffInteractionInfo); - Map onOffoffWithEffectCommandParams = new LinkedHashMap(); - CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = new CommandParameterInfo("effectId", Integer.class); - onOffoffWithEffectCommandParams.put("effectId",onOffoffWithEffecteffectIdCommandParameterInfo); - - CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = new CommandParameterInfo("effectVariant", Integer.class); - onOffoffWithEffectCommandParams.put("effectVariant",onOffoffWithEffecteffectVariantCommandParameterInfo); - - InteractionInfo onOffoffWithEffectInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .offWithEffect((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("effectId") - , (Integer) - commandArguments.get("effectVariant") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffoffWithEffectCommandParams - ); - onOffClusterInteractionInfoMap.put("offWithEffect", onOffoffWithEffectInteractionInfo); - Map onOffonCommandParams = new LinkedHashMap(); - InteractionInfo onOffonInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .on((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonCommandParams - ); - onOffClusterInteractionInfoMap.put("on", onOffonInteractionInfo); - Map onOffonWithRecallGlobalSceneCommandParams = new LinkedHashMap(); - InteractionInfo onOffonWithRecallGlobalSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .onWithRecallGlobalScene((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonWithRecallGlobalSceneCommandParams - ); - onOffClusterInteractionInfoMap.put("onWithRecallGlobalScene", onOffonWithRecallGlobalSceneInteractionInfo); - Map onOffonWithTimedOffCommandParams = new LinkedHashMap(); - CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = new CommandParameterInfo("onOffControl", Integer.class); - onOffonWithTimedOffCommandParams.put("onOffControl",onOffonWithTimedOffonOffControlCommandParameterInfo); - - CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = new CommandParameterInfo("onTime", Integer.class); - onOffonWithTimedOffCommandParams.put("onTime",onOffonWithTimedOffonTimeCommandParameterInfo); - - CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("offWaitTime", Integer.class); - onOffonWithTimedOffCommandParams.put("offWaitTime",onOffonWithTimedOffoffWaitTimeCommandParameterInfo); - - InteractionInfo onOffonWithTimedOffInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .onWithTimedOff((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("onOffControl") - , (Integer) - commandArguments.get("onTime") - , (Integer) - commandArguments.get("offWaitTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOffonWithTimedOffCommandParams - ); - onOffClusterInteractionInfoMap.put("onWithTimedOff", onOffonWithTimedOffInteractionInfo); - Map onOfftoggleCommandParams = new LinkedHashMap(); - InteractionInfo onOfftoggleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster) - .toggle((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - onOfftoggleCommandParams - ); - onOffClusterInteractionInfoMap.put("toggle", onOfftoggleInteractionInfo); - commandMap.put("onOff", onOffClusterInteractionInfoMap); - Map onOffSwitchConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInteractionInfoMap); - Map operationalCredentialsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map operationalCredentialsaddNOCCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); - operationalCredentialsaddNOCCommandParams.put("NOCValue",operationalCredentialsaddNOCNOCValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); - operationalCredentialsaddNOCCommandParams.put("ICACValue",operationalCredentialsaddNOCICACValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = new CommandParameterInfo("IPKValue", byte[].class); - operationalCredentialsaddNOCCommandParams.put("IPKValue",operationalCredentialsaddNOCIPKValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = new CommandParameterInfo("caseAdminNode", Long.class); - operationalCredentialsaddNOCCommandParams.put("caseAdminNode",operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); - - CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = new CommandParameterInfo("adminVendorId", Integer.class); - operationalCredentialsaddNOCCommandParams.put("adminVendorId",operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); - - InteractionInfo operationalCredentialsaddNOCInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .addNOC((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (byte[]) - commandArguments.get("NOCValue") - , (Optional) - commandArguments.get("ICACValue") - , (byte[]) - commandArguments.get("IPKValue") - , (Long) - commandArguments.get("caseAdminNode") - , (Integer) - commandArguments.get("adminVendorId") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsaddNOCCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("addNOC", operationalCredentialsaddNOCInteractionInfo); - Map operationalCredentialsaddTrustedRootCertificateCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = new CommandParameterInfo("rootCertificate", byte[].class); - operationalCredentialsaddTrustedRootCertificateCommandParams.put("rootCertificate",operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); - - InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .addTrustedRootCertificate((DefaultClusterCallback) callback - , (byte[]) - commandArguments.get("rootCertificate") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - operationalCredentialsaddTrustedRootCertificateCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("addTrustedRootCertificate", operationalCredentialsaddTrustedRootCertificateInteractionInfo); - Map operationalCredentialsattestationRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = new CommandParameterInfo("attestationNonce", byte[].class); - operationalCredentialsattestationRequestCommandParams.put("attestationNonce",operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); - - InteractionInfo operationalCredentialsattestationRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .attestationRequest((ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) callback - , (byte[]) - commandArguments.get("attestationNonce") - - ); - }, - () -> new DelegatedAttestationResponseCallback(), - operationalCredentialsattestationRequestCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("attestationRequest", operationalCredentialsattestationRequestInteractionInfo); - Map operationalCredentialscertificateChainRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = new CommandParameterInfo("certificateType", Integer.class); - operationalCredentialscertificateChainRequestCommandParams.put("certificateType",operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); - - InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .certificateChainRequest((ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) callback - , (Integer) - commandArguments.get("certificateType") - - ); - }, - () -> new DelegatedCertificateChainResponseCallback(), - operationalCredentialscertificateChainRequestCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("certificateChainRequest", operationalCredentialscertificateChainRequestInteractionInfo); - Map operationalCredentialsopCSRRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = new CommandParameterInfo("CSRNonce", byte[].class); - operationalCredentialsopCSRRequestCommandParams.put("CSRNonce",operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); - - InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .opCSRRequest((ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback - , (byte[]) - commandArguments.get("CSRNonce") - - ); - }, - () -> new DelegatedOpCSRResponseCallback(), - operationalCredentialsopCSRRequestCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("opCSRRequest", operationalCredentialsopCSRRequestInteractionInfo); - Map operationalCredentialsremoveFabricCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = new CommandParameterInfo("fabricIndex", Integer.class); - operationalCredentialsremoveFabricCommandParams.put("fabricIndex",operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); - - InteractionInfo operationalCredentialsremoveFabricInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .removeFabric((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (Integer) - commandArguments.get("fabricIndex") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsremoveFabricCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("removeFabric", operationalCredentialsremoveFabricInteractionInfo); - Map operationalCredentialsremoveTrustedRootCertificateCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = new CommandParameterInfo("trustedRootIdentifier", byte[].class); - operationalCredentialsremoveTrustedRootCertificateCommandParams.put("trustedRootIdentifier",operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); - - InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .removeTrustedRootCertificate((DefaultClusterCallback) callback - , (byte[]) - commandArguments.get("trustedRootIdentifier") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - operationalCredentialsremoveTrustedRootCertificateCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("removeTrustedRootCertificate", operationalCredentialsremoveTrustedRootCertificateInteractionInfo); - Map operationalCredentialsupdateFabricLabelCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = new CommandParameterInfo("label", String.class); - operationalCredentialsupdateFabricLabelCommandParams.put("label",operationalCredentialsupdateFabricLabellabelCommandParameterInfo); - - InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .updateFabricLabel((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (String) - commandArguments.get("label") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsupdateFabricLabelCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("updateFabricLabel", operationalCredentialsupdateFabricLabelInteractionInfo); - Map operationalCredentialsupdateNOCCommandParams = new LinkedHashMap(); - CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = new CommandParameterInfo("NOCValue", byte[].class); - operationalCredentialsupdateNOCCommandParams.put("NOCValue",operationalCredentialsupdateNOCNOCValueCommandParameterInfo); - - CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = new CommandParameterInfo("ICACValue", Optional.class); - operationalCredentialsupdateNOCCommandParams.put("ICACValue",operationalCredentialsupdateNOCICACValueCommandParameterInfo); - - InteractionInfo operationalCredentialsupdateNOCInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster) - .updateNOC((ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback - , (byte[]) - commandArguments.get("NOCValue") - , (Optional) - commandArguments.get("ICACValue") - - ); - }, - () -> new DelegatedNOCResponseCallback(), - operationalCredentialsupdateNOCCommandParams - ); - operationalCredentialsClusterInteractionInfoMap.put("updateNOC", operationalCredentialsupdateNOCInteractionInfo); - commandMap.put("operationalCredentials", operationalCredentialsClusterInteractionInfoMap); - Map powerSourceClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("powerSource", powerSourceClusterInteractionInfoMap); - Map powerSourceConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInteractionInfoMap); - Map pressureMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("pressureMeasurement", pressureMeasurementClusterInteractionInfoMap); - Map pumpConfigurationAndControlClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInteractionInfoMap); - Map relativeHumidityMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInteractionInfoMap); - Map scenesClusterInteractionInfoMap = new LinkedHashMap<>(); - Map scenesaddSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesaddSceneCommandParams.put("groupId",scenesaddScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesaddSceneCommandParams.put("sceneId",scenesaddScenesceneIdCommandParameterInfo); - - CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - scenesaddSceneCommandParams.put("transitionTime",scenesaddScenetransitionTimeCommandParameterInfo); - - CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = new CommandParameterInfo("sceneName", String.class); - scenesaddSceneCommandParams.put("sceneName",scenesaddScenesceneNameCommandParameterInfo); - - InteractionInfo scenesaddSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .addScene((ChipClusters.ScenesCluster.AddSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - , (Integer) - commandArguments.get("transitionTime") - , (String) - commandArguments.get("sceneName") - , (ArrayList) - commandArguments.get("extensionFieldSets") - - ); - }, - () -> new DelegatedAddSceneResponseCallback(), - scenesaddSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("addScene", scenesaddSceneInteractionInfo); - Map scenesgetSceneMembershipCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesgetSceneMembershipCommandParams.put("groupId",scenesgetSceneMembershipgroupIdCommandParameterInfo); - - InteractionInfo scenesgetSceneMembershipInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .getSceneMembership((ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedGetSceneMembershipResponseCallback(), - scenesgetSceneMembershipCommandParams - ); - scenesClusterInteractionInfoMap.put("getSceneMembership", scenesgetSceneMembershipInteractionInfo); - Map scenesrecallSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesrecallSceneCommandParams.put("groupId",scenesrecallScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesrecallSceneCommandParams.put("sceneId",scenesrecallScenesceneIdCommandParameterInfo); - - CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = new CommandParameterInfo("transitionTime", Integer.class); - scenesrecallSceneCommandParams.put("transitionTime",scenesrecallScenetransitionTimeCommandParameterInfo); - - InteractionInfo scenesrecallSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .recallScene((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - , (Integer) - commandArguments.get("transitionTime") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - scenesrecallSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("recallScene", scenesrecallSceneInteractionInfo); - Map scenesremoveAllScenesCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesremoveAllScenesCommandParams.put("groupId",scenesremoveAllScenesgroupIdCommandParameterInfo); - - InteractionInfo scenesremoveAllScenesInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .removeAllScenes((ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - - ); - }, - () -> new DelegatedRemoveAllScenesResponseCallback(), - scenesremoveAllScenesCommandParams - ); - scenesClusterInteractionInfoMap.put("removeAllScenes", scenesremoveAllScenesInteractionInfo); - Map scenesremoveSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesremoveSceneCommandParams.put("groupId",scenesremoveScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesremoveSceneCommandParams.put("sceneId",scenesremoveScenesceneIdCommandParameterInfo); - - InteractionInfo scenesremoveSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .removeScene((ChipClusters.ScenesCluster.RemoveSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - - ); - }, - () -> new DelegatedRemoveSceneResponseCallback(), - scenesremoveSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("removeScene", scenesremoveSceneInteractionInfo); - Map scenesstoreSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesstoreSceneCommandParams.put("groupId",scenesstoreScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesstoreSceneCommandParams.put("sceneId",scenesstoreScenesceneIdCommandParameterInfo); - - InteractionInfo scenesstoreSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .storeScene((ChipClusters.ScenesCluster.StoreSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - - ); - }, - () -> new DelegatedStoreSceneResponseCallback(), - scenesstoreSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("storeScene", scenesstoreSceneInteractionInfo); - Map scenesviewSceneCommandParams = new LinkedHashMap(); - CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = new CommandParameterInfo("groupId", Integer.class); - scenesviewSceneCommandParams.put("groupId",scenesviewScenegroupIdCommandParameterInfo); - - CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = new CommandParameterInfo("sceneId", Integer.class); - scenesviewSceneCommandParams.put("sceneId",scenesviewScenesceneIdCommandParameterInfo); - - InteractionInfo scenesviewSceneInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster) - .viewScene((ChipClusters.ScenesCluster.ViewSceneResponseCallback) callback - , (Integer) - commandArguments.get("groupId") - , (Integer) - commandArguments.get("sceneId") - - ); - }, - () -> new DelegatedViewSceneResponseCallback(), - scenesviewSceneCommandParams - ); - scenesClusterInteractionInfoMap.put("viewScene", scenesviewSceneInteractionInfo); - commandMap.put("scenes", scenesClusterInteractionInfoMap); - Map softwareDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map softwareDiagnosticsresetWatermarksCommandParams = new LinkedHashMap(); - InteractionInfo softwareDiagnosticsresetWatermarksInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster) - .resetWatermarks((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - softwareDiagnosticsresetWatermarksCommandParams - ); - softwareDiagnosticsClusterInteractionInfoMap.put("resetWatermarks", softwareDiagnosticsresetWatermarksInteractionInfo); - commandMap.put("softwareDiagnostics", softwareDiagnosticsClusterInteractionInfoMap); - Map switchClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("switch", switchClusterInteractionInfoMap); - Map targetNavigatorClusterInteractionInfoMap = new LinkedHashMap<>(); - Map targetNavigatornavigateTargetRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = new CommandParameterInfo("target", Integer.class); - targetNavigatornavigateTargetRequestCommandParams.put("target",targetNavigatornavigateTargetRequesttargetCommandParameterInfo); - - CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = new CommandParameterInfo("data", String.class); - targetNavigatornavigateTargetRequestCommandParams.put("data",targetNavigatornavigateTargetRequestdataCommandParameterInfo); - - InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster) - .navigateTargetRequest((ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback) callback - , (Integer) - commandArguments.get("target") - , (String) - commandArguments.get("data") - - ); - }, - () -> new DelegatedNavigateTargetResponseCallback(), - targetNavigatornavigateTargetRequestCommandParams - ); - targetNavigatorClusterInteractionInfoMap.put("navigateTargetRequest", targetNavigatornavigateTargetRequestInteractionInfo); - commandMap.put("targetNavigator", targetNavigatorClusterInteractionInfoMap); - Map temperatureMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); - Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); - Map testClustersimpleStructEchoRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustersimpleStructEchoRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .simpleStructEchoRequest((ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback - , (ChipStructs.TestClusterClusterSimpleStruct) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedSimpleStructResponseCallback(), - testClustersimpleStructEchoRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("simpleStructEchoRequest", testClustersimpleStructEchoRequestInteractionInfo); - Map testClustertestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .test((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestCommandParams - ); - testClusterClusterInteractionInfoMap.put("test", testClustertestInteractionInfo); - Map testClustertestAddArgumentsCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); - testClustertestAddArgumentsCommandParams.put("arg1",testClustertestAddArgumentsarg1CommandParameterInfo); - - CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); - testClustertestAddArgumentsCommandParams.put("arg2",testClustertestAddArgumentsarg2CommandParameterInfo); - - InteractionInfo testClustertestAddArgumentsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testAddArguments((ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback) callback - , (Integer) - commandArguments.get("arg1") - , (Integer) - commandArguments.get("arg2") - - ); - }, - () -> new DelegatedTestAddArgumentsResponseCallback(), - testClustertestAddArgumentsCommandParams - ); - testClusterClusterInteractionInfoMap.put("testAddArguments", testClustertestAddArgumentsInteractionInfo); - Map testClustertestEmitTestEventRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); - testClustertestEmitTestEventRequestCommandParams.put("arg1",testClustertestEmitTestEventRequestarg1CommandParameterInfo); - - CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); - testClustertestEmitTestEventRequestCommandParams.put("arg2",testClustertestEmitTestEventRequestarg2CommandParameterInfo); - - CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = new CommandParameterInfo("arg3", Boolean.class); - testClustertestEmitTestEventRequestCommandParams.put("arg3",testClustertestEmitTestEventRequestarg3CommandParameterInfo); - - InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testEmitTestEventRequest((ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback) callback - , (Integer) - commandArguments.get("arg1") - , (Integer) - commandArguments.get("arg2") - , (Boolean) - commandArguments.get("arg3") - - ); - }, - () -> new DelegatedTestEmitTestEventResponseCallback(), - testClustertestEmitTestEventRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testEmitTestEventRequest", testClustertestEmitTestEventRequestInteractionInfo); - Map testClustertestEnumsRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Integer.class); - testClustertestEnumsRequestCommandParams.put("arg1",testClustertestEnumsRequestarg1CommandParameterInfo); - - CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = new CommandParameterInfo("arg2", Integer.class); - testClustertestEnumsRequestCommandParams.put("arg2",testClustertestEnumsRequestarg2CommandParameterInfo); - - InteractionInfo testClustertestEnumsRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testEnumsRequest((ChipClusters.TestClusterCluster.TestEnumsResponseCallback) callback - , (Integer) - commandArguments.get("arg1") - , (Integer) - commandArguments.get("arg2") - - ); - }, - () -> new DelegatedTestEnumsResponseCallback(), - testClustertestEnumsRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testEnumsRequest", testClustertestEnumsRequestInteractionInfo); - Map testClustertestListInt8UArgumentRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); - testClustertestListInt8UArgumentRequestCommandParams.put("arg1",testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListInt8UArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListInt8UArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestInteractionInfo); - Map testClustertestListInt8UReverseRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", ArrayList.class); - testClustertestListInt8UReverseRequestCommandParams.put("arg1",testClustertestListInt8UReverseRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListInt8UReverseRequest((ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedTestListInt8UReverseResponseCallback(), - testClustertestListInt8UReverseRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListInt8UReverseRequest", testClustertestListInt8UReverseRequestInteractionInfo); - Map testClustertestListNestedStructListArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestListNestedStructListArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListNestedStructListArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListNestedStructListArgumentRequest", testClustertestListNestedStructListArgumentRequestInteractionInfo); - Map testClustertestListStructArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testListStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ArrayList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestListStructArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testListStructArgumentRequest", testClustertestListStructArgumentRequestInteractionInfo); - Map testClustertestNestedStructArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestNestedStructArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNestedStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ChipStructs.TestClusterClusterNestedStruct) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestNestedStructArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNestedStructArgumentRequest", testClustertestNestedStructArgumentRequestInteractionInfo); - Map testClustertestNestedStructListArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestNestedStructListArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNestedStructListArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ChipStructs.TestClusterClusterNestedStructList) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestNestedStructListArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNestedStructListArgumentRequest", testClustertestNestedStructListArgumentRequestInteractionInfo); - Map testClustertestNotHandledCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestNotHandledInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNotHandled((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestNotHandledCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNotHandled", testClustertestNotHandledInteractionInfo); - Map testClustertestNullableOptionalRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); - testClustertestNullableOptionalRequestCommandParams.put("arg1",testClustertestNullableOptionalRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testNullableOptionalRequest((ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) callback - , (Optional) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedTestNullableOptionalResponseCallback(), - testClustertestNullableOptionalRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testNullableOptionalRequest", testClustertestNullableOptionalRequestInteractionInfo); - Map testClustertestSimpleOptionalArgumentRequestCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = new CommandParameterInfo("arg1", Optional.class); - testClustertestSimpleOptionalArgumentRequestCommandParams.put("arg1",testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); - - InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testSimpleOptionalArgumentRequest((DefaultClusterCallback) callback - , (Optional) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestSimpleOptionalArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testSimpleOptionalArgumentRequest", testClustertestSimpleOptionalArgumentRequestInteractionInfo); - Map testClustertestSpecificCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestSpecificInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testSpecific((ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback - - ); - }, - () -> new DelegatedTestSpecificResponseCallback(), - testClustertestSpecificCommandParams - ); - testClusterClusterInteractionInfoMap.put("testSpecific", testClustertestSpecificInteractionInfo); - Map testClustertestStructArgumentRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestStructArgumentRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testStructArgumentRequest((ChipClusters.TestClusterCluster.BooleanResponseCallback) callback - , (ChipStructs.TestClusterClusterSimpleStruct) - commandArguments.get("arg1") - - ); - }, - () -> new DelegatedBooleanResponseCallback(), - testClustertestStructArgumentRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("testStructArgumentRequest", testClustertestStructArgumentRequestInteractionInfo); - Map testClustertestUnknownCommandCommandParams = new LinkedHashMap(); - InteractionInfo testClustertestUnknownCommandInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .testUnknownCommand((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertestUnknownCommandCommandParams - ); - testClusterClusterInteractionInfoMap.put("testUnknownCommand", testClustertestUnknownCommandInteractionInfo); - Map testClustertimedInvokeRequestCommandParams = new LinkedHashMap(); - InteractionInfo testClustertimedInvokeRequestInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster) - .timedInvokeRequest((DefaultClusterCallback) callback - , 10000 - ); - }, - () -> new DelegatedDefaultClusterCallback(), - testClustertimedInvokeRequestCommandParams - ); - testClusterClusterInteractionInfoMap.put("timedInvokeRequest", testClustertimedInvokeRequestInteractionInfo); - commandMap.put("testCluster", testClusterClusterInteractionInfoMap); - Map thermostatClusterInteractionInfoMap = new LinkedHashMap<>(); - Map thermostatclearWeeklyScheduleCommandParams = new LinkedHashMap(); - InteractionInfo thermostatclearWeeklyScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .clearWeeklySchedule((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatclearWeeklyScheduleCommandParams - ); - thermostatClusterInteractionInfoMap.put("clearWeeklySchedule", thermostatclearWeeklyScheduleInteractionInfo); - Map thermostatgetRelayStatusLogCommandParams = new LinkedHashMap(); - InteractionInfo thermostatgetRelayStatusLogInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .getRelayStatusLog((ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback - - ); - }, - () -> new DelegatedGetRelayStatusLogResponseCallback(), - thermostatgetRelayStatusLogCommandParams - ); - thermostatClusterInteractionInfoMap.put("getRelayStatusLog", thermostatgetRelayStatusLogInteractionInfo); - Map thermostatgetWeeklyScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = new CommandParameterInfo("daysToReturn", Integer.class); - thermostatgetWeeklyScheduleCommandParams.put("daysToReturn",thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); - - CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = new CommandParameterInfo("modeToReturn", Integer.class); - thermostatgetWeeklyScheduleCommandParams.put("modeToReturn",thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); - - InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .getWeeklySchedule((ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback) callback - , (Integer) - commandArguments.get("daysToReturn") - , (Integer) - commandArguments.get("modeToReturn") - - ); - }, - () -> new DelegatedGetWeeklyScheduleResponseCallback(), - thermostatgetWeeklyScheduleCommandParams - ); - thermostatClusterInteractionInfoMap.put("getWeeklySchedule", thermostatgetWeeklyScheduleInteractionInfo); - Map thermostatsetWeeklyScheduleCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put("numberOfTransitionsForSequence",thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = new CommandParameterInfo("dayOfWeekForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put("dayOfWeekForSequence",thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = new CommandParameterInfo("modeForSequence", Integer.class); - thermostatsetWeeklyScheduleCommandParams.put("modeForSequence",thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); - - CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = new CommandParameterInfo("payload", ArrayList.class); - thermostatsetWeeklyScheduleCommandParams.put("payload",thermostatsetWeeklySchedulepayloadCommandParameterInfo); - - InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .setWeeklySchedule((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("numberOfTransitionsForSequence") - , (Integer) - commandArguments.get("dayOfWeekForSequence") - , (Integer) - commandArguments.get("modeForSequence") - , (ArrayList) - commandArguments.get("payload") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatsetWeeklyScheduleCommandParams - ); - thermostatClusterInteractionInfoMap.put("setWeeklySchedule", thermostatsetWeeklyScheduleInteractionInfo); - Map thermostatsetpointRaiseLowerCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = new CommandParameterInfo("mode", Integer.class); - thermostatsetpointRaiseLowerCommandParams.put("mode",thermostatsetpointRaiseLowermodeCommandParameterInfo); - - CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = new CommandParameterInfo("amount", Integer.class); - thermostatsetpointRaiseLowerCommandParams.put("amount",thermostatsetpointRaiseLoweramountCommandParameterInfo); - - InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster) - .setpointRaiseLower((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("mode") - , (Integer) - commandArguments.get("amount") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - thermostatsetpointRaiseLowerCommandParams - ); - thermostatClusterInteractionInfoMap.put("setpointRaiseLower", thermostatsetpointRaiseLowerInteractionInfo); - commandMap.put("thermostat", thermostatClusterInteractionInfoMap); - Map thermostatUserInterfaceConfigurationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInteractionInfoMap); - Map threadNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map threadNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); - InteractionInfo threadNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - threadNetworkDiagnosticsresetCountsCommandParams - ); - threadNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", threadNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInteractionInfoMap); - Map timeFormatLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("timeFormatLocalization", timeFormatLocalizationClusterInteractionInfoMap); - Map unitLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("unitLocalization", unitLocalizationClusterInteractionInfoMap); - Map userLabelClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("userLabel", userLabelClusterInteractionInfoMap); - Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); - commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); - Map wiFiNetworkDiagnosticsClusterInteractionInfoMap = new LinkedHashMap<>(); - Map wiFiNetworkDiagnosticsresetCountsCommandParams = new LinkedHashMap(); - InteractionInfo wiFiNetworkDiagnosticsresetCountsInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) - .resetCounts((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - wiFiNetworkDiagnosticsresetCountsCommandParams - ); - wiFiNetworkDiagnosticsClusterInteractionInfoMap.put("resetCounts", wiFiNetworkDiagnosticsresetCountsInteractionInfo); - commandMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInteractionInfoMap); - Map windowCoveringClusterInteractionInfoMap = new LinkedHashMap<>(); - Map windowCoveringdownOrCloseCommandParams = new LinkedHashMap(); - InteractionInfo windowCoveringdownOrCloseInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .downOrClose((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringdownOrCloseCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("downOrClose", windowCoveringdownOrCloseInteractionInfo); - Map windowCoveringgoToLiftPercentageCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = new CommandParameterInfo("liftPercentageValue", Integer.class); - windowCoveringgoToLiftPercentageCommandParams.put("liftPercentageValue",windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); - - CommandParameterInfo windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = new CommandParameterInfo("liftPercent100thsValue", Integer.class); - windowCoveringgoToLiftPercentageCommandParams.put("liftPercent100thsValue",windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToLiftPercentage((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("liftPercentageValue") - , (Integer) - commandArguments.get("liftPercent100thsValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToLiftPercentageCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToLiftPercentage", windowCoveringgoToLiftPercentageInteractionInfo); - Map windowCoveringgoToLiftValueCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = new CommandParameterInfo("liftValue", Integer.class); - windowCoveringgoToLiftValueCommandParams.put("liftValue",windowCoveringgoToLiftValueliftValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToLiftValueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToLiftValue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("liftValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToLiftValueCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToLiftValue", windowCoveringgoToLiftValueInteractionInfo); - Map windowCoveringgoToTiltPercentageCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = new CommandParameterInfo("tiltPercentageValue", Integer.class); - windowCoveringgoToTiltPercentageCommandParams.put("tiltPercentageValue",windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); - - CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = new CommandParameterInfo("tiltPercent100thsValue", Integer.class); - windowCoveringgoToTiltPercentageCommandParams.put("tiltPercent100thsValue",windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToTiltPercentage((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("tiltPercentageValue") - , (Integer) - commandArguments.get("tiltPercent100thsValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToTiltPercentageCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToTiltPercentage", windowCoveringgoToTiltPercentageInteractionInfo); - Map windowCoveringgoToTiltValueCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = new CommandParameterInfo("tiltValue", Integer.class); - windowCoveringgoToTiltValueCommandParams.put("tiltValue",windowCoveringgoToTiltValuetiltValueCommandParameterInfo); - - InteractionInfo windowCoveringgoToTiltValueInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .goToTiltValue((DefaultClusterCallback) callback - , (Integer) - commandArguments.get("tiltValue") - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringgoToTiltValueCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("goToTiltValue", windowCoveringgoToTiltValueInteractionInfo); - Map windowCoveringstopMotionCommandParams = new LinkedHashMap(); - InteractionInfo windowCoveringstopMotionInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .stopMotion((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringstopMotionCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("stopMotion", windowCoveringstopMotionInteractionInfo); - Map windowCoveringupOrOpenCommandParams = new LinkedHashMap(); - InteractionInfo windowCoveringupOrOpenInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster) - .upOrOpen((DefaultClusterCallback) callback - - ); - }, - () -> new DelegatedDefaultClusterCallback(), - windowCoveringupOrOpenCommandParams - ); - windowCoveringClusterInteractionInfoMap.put("upOrOpen", windowCoveringupOrOpenInteractionInfo); - commandMap.put("windowCovering", windowCoveringClusterInteractionInfoMap); - return commandMap; + @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 DelegatedAccessControlClusterExtensionAttributeCallback + implements ChipClusters.AccessControlCluster.ExtensionAttributeCallback, + 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 DelegatedAccessControlClusterAttributeListAttributeCallback + implements ChipClusters.AccessControlCluster.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 DelegatedGetSetupPINResponseCallback + implements ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(String setupPIN) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("setupPIN", "String"); + responseValues.put(setupPINResponseValue, setupPIN); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedAccountLoginClusterAttributeListAttributeCallback + implements ChipClusters.AccountLoginCluster.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 DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback + implements ChipClusters.AdministratorCommissioningCluster.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 DelegatedApplicationBasicClusterAllowedVendorListAttributeCallback + implements ChipClusters.ApplicationBasicCluster.AllowedVendorListAttributeCallback, + 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 DelegatedApplicationBasicClusterAttributeListAttributeCallback + implements ChipClusters.ApplicationBasicCluster.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 DelegatedLauncherResponseCallback + implements ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback + implements ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback, + 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 DelegatedApplicationLauncherClusterAttributeListAttributeCallback + implements ChipClusters.ApplicationLauncherCluster.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 DelegatedAudioOutputClusterAudioOutputListAttributeCallback + implements ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback, + 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 DelegatedAudioOutputClusterAttributeListAttributeCallback + implements ChipClusters.AudioOutputCluster.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 DelegatedBarrierControlClusterAttributeListAttributeCallback + implements ChipClusters.BarrierControlCluster.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 DelegatedBasicClusterAttributeListAttributeCallback + implements ChipClusters.BasicCluster.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 DelegatedBinaryInputBasicClusterAttributeListAttributeCallback + implements ChipClusters.BinaryInputBasicCluster.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 DelegatedBindingClusterAttributeListAttributeCallback + implements ChipClusters.BindingCluster.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 DelegatedBooleanStateClusterAttributeListAttributeCallback + implements ChipClusters.BooleanStateCluster.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 DelegatedBridgedActionsClusterActionListAttributeCallback + implements ChipClusters.BridgedActionsCluster.ActionListAttributeCallback, + 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 DelegatedBridgedActionsClusterEndpointListAttributeCallback + implements ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback, + 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 DelegatedBridgedActionsClusterAttributeListAttributeCallback + implements ChipClusters.BridgedActionsCluster.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 DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback + implements ChipClusters.BridgedDeviceBasicCluster.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 DelegatedChangeChannelResponseCallback + implements ChipClusters.ChannelCluster.ChangeChannelResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.ChannelClusterChannelInfo channelMatch, Integer errorType) { + Map responseValues = new LinkedHashMap<>(); + // channelMatch: Struct ChannelInfo + // Conversion from this type to Java is not properly implemented yet + CommandResponseInfo errorTypeResponseValue = new CommandResponseInfo("errorType", "Integer"); + responseValues.put(errorTypeResponseValue, errorType); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedChannelClusterChannelListAttributeCallback + implements ChipClusters.ChannelCluster.ChannelListAttributeCallback, + 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 DelegatedChannelClusterAttributeListAttributeCallback + implements ChipClusters.ChannelCluster.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 DelegatedColorControlClusterAttributeListAttributeCallback + implements ChipClusters.ColorControlCluster.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 DelegatedLaunchResponseCallback + implements ChipClusters.ContentLauncherCluster.LaunchResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback + implements ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback, + 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 DelegatedContentLauncherClusterAttributeListAttributeCallback + implements ChipClusters.ContentLauncherCluster.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 DelegatedDescriptorClusterDeviceListAttributeCallback + implements ChipClusters.DescriptorCluster.DeviceListAttributeCallback, + 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 DelegatedDescriptorClusterServerListAttributeCallback + implements ChipClusters.DescriptorCluster.ServerListAttributeCallback, + 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 DelegatedDescriptorClusterClientListAttributeCallback + implements ChipClusters.DescriptorCluster.ClientListAttributeCallback, + 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 DelegatedDescriptorClusterPartsListAttributeCallback + implements ChipClusters.DescriptorCluster.PartsListAttributeCallback, + 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 DelegatedDescriptorClusterAttributeListAttributeCallback + implements ChipClusters.DescriptorCluster.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 DelegatedRetrieveLogsResponseCallback + implements ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, byte[] content, Long timeStamp, Long timeSinceBoot) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo contentResponseValue = new CommandResponseInfo("content", "byte[]"); + responseValues.put(contentResponseValue, content); + CommandResponseInfo timeStampResponseValue = new CommandResponseInfo("timeStamp", "Long"); + responseValues.put(timeStampResponseValue, timeStamp); + CommandResponseInfo timeSinceBootResponseValue = + new CommandResponseInfo("timeSinceBoot", "Long"); + responseValues.put(timeSinceBootResponseValue, timeSinceBoot); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedDiagnosticLogsClusterAttributeListAttributeCallback + implements ChipClusters.DiagnosticLogsCluster.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 DelegatedGetCredentialStatusResponseCallback + implements ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Boolean credentialExists, + @Nullable Integer userIndex, + @Nullable Integer nextCredentialIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo credentialExistsResponseValue = + new CommandResponseInfo("credentialExists", "Boolean"); + responseValues.put(credentialExistsResponseValue, credentialExists); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo nextCredentialIndexResponseValue = + new CommandResponseInfo("nextCredentialIndex", "Integer"); + responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetUserResponseCallback + implements ChipClusters.DoorLockCluster.GetUserResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer userIndex, + @Nullable String userName, + @Nullable Long userUniqueId, + @Nullable Integer userStatus, + @Nullable Integer userType, + @Nullable Integer credentialRule, + @Nullable ArrayList credentials, + @Nullable Integer creatorFabricIndex, + @Nullable Integer lastModifiedFabricIndex, + @Nullable Integer nextUserIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo userNameResponseValue = new CommandResponseInfo("userName", "String"); + responseValues.put(userNameResponseValue, userName); + CommandResponseInfo userUniqueIdResponseValue = + new CommandResponseInfo("userUniqueId", "Long"); + responseValues.put(userUniqueIdResponseValue, userUniqueId); + CommandResponseInfo userStatusResponseValue = + new CommandResponseInfo("userStatus", "Integer"); + responseValues.put(userStatusResponseValue, userStatus); + CommandResponseInfo userTypeResponseValue = new CommandResponseInfo("userType", "Integer"); + responseValues.put(userTypeResponseValue, userType); + CommandResponseInfo credentialRuleResponseValue = + new CommandResponseInfo("credentialRule", "Integer"); + responseValues.put(credentialRuleResponseValue, credentialRule); + // credentials: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + CommandResponseInfo creatorFabricIndexResponseValue = + new CommandResponseInfo("creatorFabricIndex", "Integer"); + responseValues.put(creatorFabricIndexResponseValue, creatorFabricIndex); + CommandResponseInfo lastModifiedFabricIndexResponseValue = + new CommandResponseInfo("lastModifiedFabricIndex", "Integer"); + responseValues.put(lastModifiedFabricIndexResponseValue, lastModifiedFabricIndex); + CommandResponseInfo nextUserIndexResponseValue = + new CommandResponseInfo("nextUserIndex", "Integer"); + responseValues.put(nextUserIndexResponseValue, nextUserIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetWeekDayScheduleResponseCallback + implements ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer weekDayIndex, + Integer userIndex, + Integer status, + Optional daysMask, + Optional startHour, + Optional startMinute, + Optional endHour, + Optional endMinute) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo weekDayIndexResponseValue = + new CommandResponseInfo("weekDayIndex", "Integer"); + responseValues.put(weekDayIndexResponseValue, weekDayIndex); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo daysMaskResponseValue = + new CommandResponseInfo("daysMask", "Optional"); + responseValues.put(daysMaskResponseValue, daysMask); + CommandResponseInfo startHourResponseValue = + new CommandResponseInfo("startHour", "Optional"); + responseValues.put(startHourResponseValue, startHour); + CommandResponseInfo startMinuteResponseValue = + new CommandResponseInfo("startMinute", "Optional"); + responseValues.put(startMinuteResponseValue, startMinute); + CommandResponseInfo endHourResponseValue = + new CommandResponseInfo("endHour", "Optional"); + responseValues.put(endHourResponseValue, endHour); + CommandResponseInfo endMinuteResponseValue = + new CommandResponseInfo("endMinute", "Optional"); + responseValues.put(endMinuteResponseValue, endMinute); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetYearDayScheduleResponseCallback + implements ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer yearDayIndex, + Integer userIndex, + Integer status, + Optional localStartTime, + Optional localEndTime) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo yearDayIndexResponseValue = + new CommandResponseInfo("yearDayIndex", "Integer"); + responseValues.put(yearDayIndexResponseValue, yearDayIndex); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo localStartTimeResponseValue = + new CommandResponseInfo("localStartTime", "Optional"); + responseValues.put(localStartTimeResponseValue, localStartTime); + CommandResponseInfo localEndTimeResponseValue = + new CommandResponseInfo("localEndTime", "Optional"); + responseValues.put(localEndTimeResponseValue, localEndTime); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSetCredentialResponseCallback + implements ChipClusters.DoorLockCluster.SetCredentialResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, @Nullable Integer userIndex, @Nullable Integer nextCredentialIndex) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo userIndexResponseValue = new CommandResponseInfo("userIndex", "Integer"); + responseValues.put(userIndexResponseValue, userIndex); + CommandResponseInfo nextCredentialIndexResponseValue = + new CommandResponseInfo("nextCredentialIndex", "Integer"); + responseValues.put(nextCredentialIndexResponseValue, nextCredentialIndex); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedDoorLockClusterAttributeListAttributeCallback + implements ChipClusters.DoorLockCluster.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 DelegatedElectricalMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.ElectricalMeasurementCluster.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 DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.EthernetNetworkDiagnosticsCluster.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 DelegatedFixedLabelClusterLabelListAttributeCallback + implements ChipClusters.FixedLabelCluster.LabelListAttributeCallback, + 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 DelegatedFixedLabelClusterAttributeListAttributeCallback + implements ChipClusters.FixedLabelCluster.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 DelegatedFlowMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.FlowMeasurementCluster.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 DelegatedArmFailSafeResponseCallback + implements ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedCommissioningCompleteResponseCallback + implements ChipClusters.GeneralCommissioningCluster.CommissioningCompleteResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSetRegulatoryConfigResponseCallback + implements ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer errorCode, String debugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo errorCodeResponseValue = new CommandResponseInfo("errorCode", "Integer"); + responseValues.put(errorCodeResponseValue, errorCode); + CommandResponseInfo debugTextResponseValue = new CommandResponseInfo("debugText", "String"); + responseValues.put(debugTextResponseValue, debugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static + class DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback + implements ChipClusters.GeneralCommissioningCluster + .BasicCommissioningInfoListAttributeCallback, + 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 DelegatedGeneralCommissioningClusterAttributeListAttributeCallback + implements ChipClusters.GeneralCommissioningCluster.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 DelegatedGeneralDiagnosticsClusterNetworkInterfacesAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.NetworkInterfacesAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterActiveRadioFaultsAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.ActiveRadioFaultsAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterActiveNetworkFaultsAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.ActiveNetworkFaultsAttributeCallback, + 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 DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.GeneralDiagnosticsCluster.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 DelegatedKeySetReadAllIndicesResponseCallback + implements ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ArrayList groupKeySetIDs) { + Map responseValues = new LinkedHashMap<>(); + // groupKeySetIDs: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedKeySetReadResponseCallback + implements ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.GroupKeyManagementClusterGroupKeySet groupKeySet) { + Map responseValues = new LinkedHashMap<>(); + // groupKeySet: Struct GroupKeySet + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGroupKeyManagementClusterGroupKeyMapAttributeCallback + implements ChipClusters.GroupKeyManagementCluster.GroupKeyMapAttributeCallback, + 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 DelegatedGroupKeyManagementClusterGroupTableAttributeCallback + implements ChipClusters.GroupKeyManagementCluster.GroupTableAttributeCallback, + 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 DelegatedGroupKeyManagementClusterAttributeListAttributeCallback + implements ChipClusters.GroupKeyManagementCluster.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 DelegatedAddGroupResponseCallback + implements ChipClusters.GroupsCluster.AddGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetGroupMembershipResponseCallback + implements ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer capacity, ArrayList groupList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); + responseValues.put(capacityResponseValue, capacity); + // groupList: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveGroupResponseCallback + implements ChipClusters.GroupsCluster.RemoveGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedViewGroupResponseCallback + implements ChipClusters.GroupsCluster.ViewGroupResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, String groupName) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo groupNameResponseValue = new CommandResponseInfo("groupName", "String"); + responseValues.put(groupNameResponseValue, groupName); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGroupsClusterAttributeListAttributeCallback + implements ChipClusters.GroupsCluster.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 DelegatedIdentifyQueryResponseCallback + implements ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer timeout) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo timeoutResponseValue = new CommandResponseInfo("timeout", "Integer"); + responseValues.put(timeoutResponseValue, timeout); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedIdentifyClusterAttributeListAttributeCallback + implements ChipClusters.IdentifyCluster.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 DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.IlluminanceMeasurementCluster.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 DelegatedSendKeyResponseCallback + implements ChipClusters.KeypadInputCluster.SendKeyResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedKeypadInputClusterAttributeListAttributeCallback + implements ChipClusters.KeypadInputCluster.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 DelegatedLevelControlClusterAttributeListAttributeCallback + implements ChipClusters.LevelControlCluster.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 DelegatedLocalizationConfigurationClusterSupportedLocalesAttributeCallback + implements ChipClusters.LocalizationConfigurationCluster.SupportedLocalesAttributeCallback, + 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 DelegatedLowPowerClusterAttributeListAttributeCallback + implements ChipClusters.LowPowerCluster.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 DelegatedMediaInputClusterMediaInputListAttributeCallback + implements ChipClusters.MediaInputCluster.MediaInputListAttributeCallback, + 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 DelegatedMediaInputClusterAttributeListAttributeCallback + implements ChipClusters.MediaInputCluster.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 DelegatedPlaybackResponseCallback + implements ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedMediaPlaybackClusterAttributeListAttributeCallback + implements ChipClusters.MediaPlaybackCluster.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 DelegatedModeSelectClusterSupportedModesAttributeCallback + implements ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback, + 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 DelegatedModeSelectClusterAttributeListAttributeCallback + implements ChipClusters.ModeSelectCluster.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 DelegatedConnectNetworkResponseCallback + implements ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText, Long ErrorValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = + new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + CommandResponseInfo ErrorValueResponseValue = new CommandResponseInfo("ErrorValue", "Long"); + responseValues.put(ErrorValueResponseValue, ErrorValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNetworkConfigResponseCallback + implements ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer NetworkingStatus, String DebugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = + new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedScanNetworksResponseCallback + implements ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer NetworkingStatus, + String DebugText, + Optional> + WiFiScanResults, + Optional> + ThreadScanResults) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NetworkingStatusResponseValue = + new CommandResponseInfo("NetworkingStatus", "Integer"); + responseValues.put(NetworkingStatusResponseValue, NetworkingStatus); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + // WiFiScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + // ThreadScanResults: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNetworkCommissioningClusterNetworksAttributeCallback + implements ChipClusters.NetworkCommissioningCluster.NetworksAttributeCallback, + 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 DelegatedApplyUpdateResponseCallback + implements ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer action, Long delayedActionTime) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo actionResponseValue = new CommandResponseInfo("action", "Integer"); + responseValues.put(actionResponseValue, action); + CommandResponseInfo delayedActionTimeResponseValue = + new CommandResponseInfo("delayedActionTime", "Long"); + responseValues.put(delayedActionTimeResponseValue, delayedActionTime); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedQueryImageResponseCallback + implements ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, + Optional delayedActionTime, + Optional imageURI, + Optional softwareVersion, + Optional softwareVersionString, + Optional updateToken, + Optional userConsentNeeded, + Optional metadataForRequestor) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo delayedActionTimeResponseValue = + new CommandResponseInfo("delayedActionTime", "Optional"); + responseValues.put(delayedActionTimeResponseValue, delayedActionTime); + CommandResponseInfo imageURIResponseValue = + new CommandResponseInfo("imageURI", "Optional"); + responseValues.put(imageURIResponseValue, imageURI); + CommandResponseInfo softwareVersionResponseValue = + new CommandResponseInfo("softwareVersion", "Optional"); + responseValues.put(softwareVersionResponseValue, softwareVersion); + CommandResponseInfo softwareVersionStringResponseValue = + new CommandResponseInfo("softwareVersionString", "Optional"); + responseValues.put(softwareVersionStringResponseValue, softwareVersionString); + CommandResponseInfo updateTokenResponseValue = + new CommandResponseInfo("updateToken", "Optional"); + responseValues.put(updateTokenResponseValue, updateToken); + CommandResponseInfo userConsentNeededResponseValue = + new CommandResponseInfo("userConsentNeeded", "Optional"); + responseValues.put(userConsentNeededResponseValue, userConsentNeeded); + CommandResponseInfo metadataForRequestorResponseValue = + new CommandResponseInfo("metadataForRequestor", "Optional"); + responseValues.put(metadataForRequestorResponseValue, metadataForRequestor); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback + implements ChipClusters.OtaSoftwareUpdateProviderCluster.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 DelegatedOtaSoftwareUpdateRequestorClusterDefaultOtaProvidersAttributeCallback + implements ChipClusters.OtaSoftwareUpdateRequestorCluster + .DefaultOtaProvidersAttributeCallback, + 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 DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback + implements ChipClusters.OtaSoftwareUpdateRequestorCluster.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 DelegatedOccupancySensingClusterAttributeListAttributeCallback + implements ChipClusters.OccupancySensingCluster.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 DelegatedOnOffClusterAttributeListAttributeCallback + implements ChipClusters.OnOffCluster.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 DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback + implements ChipClusters.OnOffSwitchConfigurationCluster.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 DelegatedAttestationResponseCallback + implements ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] AttestationElements, byte[] Signature) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo AttestationElementsResponseValue = + new CommandResponseInfo("AttestationElements", "byte[]"); + responseValues.put(AttestationElementsResponseValue, AttestationElements); + CommandResponseInfo SignatureResponseValue = new CommandResponseInfo("Signature", "byte[]"); + responseValues.put(SignatureResponseValue, Signature); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedCertificateChainResponseCallback + implements ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] Certificate) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo CertificateResponseValue = + new CommandResponseInfo("Certificate", "byte[]"); + responseValues.put(CertificateResponseValue, Certificate); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedNOCResponseCallback + implements ChipClusters.OperationalCredentialsCluster.NOCResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer StatusCode, Integer FabricIndex, String DebugText) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo StatusCodeResponseValue = + new CommandResponseInfo("StatusCode", "Integer"); + responseValues.put(StatusCodeResponseValue, StatusCode); + CommandResponseInfo FabricIndexResponseValue = + new CommandResponseInfo("FabricIndex", "Integer"); + responseValues.put(FabricIndexResponseValue, FabricIndex); + CommandResponseInfo DebugTextResponseValue = new CommandResponseInfo("DebugText", "String"); + responseValues.put(DebugTextResponseValue, DebugText); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedOpCSRResponseCallback + implements ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(byte[] NOCSRElements, byte[] AttestationSignature) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo NOCSRElementsResponseValue = + new CommandResponseInfo("NOCSRElements", "byte[]"); + responseValues.put(NOCSRElementsResponseValue, NOCSRElements); + CommandResponseInfo AttestationSignatureResponseValue = + new CommandResponseInfo("AttestationSignature", "byte[]"); + responseValues.put(AttestationSignatureResponseValue, AttestationSignature); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedOperationalCredentialsClusterNOCsAttributeCallback + implements ChipClusters.OperationalCredentialsCluster.NOCsAttributeCallback, + 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 DelegatedOperationalCredentialsClusterFabricsListAttributeCallback + implements ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback, + 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 DelegatedOperationalCredentialsClusterTrustedRootCertificatesAttributeCallback + implements ChipClusters.OperationalCredentialsCluster + .TrustedRootCertificatesAttributeCallback, + 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 DelegatedOperationalCredentialsClusterAttributeListAttributeCallback + implements ChipClusters.OperationalCredentialsCluster.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 DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback + implements ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback, + 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 DelegatedPowerSourceClusterAttributeListAttributeCallback + implements ChipClusters.PowerSourceCluster.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 DelegatedPowerSourceConfigurationClusterSourcesAttributeCallback + implements ChipClusters.PowerSourceConfigurationCluster.SourcesAttributeCallback, + 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 DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback + implements ChipClusters.PowerSourceConfigurationCluster.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 DelegatedPressureMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.PressureMeasurementCluster.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 DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback + implements ChipClusters.PumpConfigurationAndControlCluster.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 DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.RelativeHumidityMeasurementCluster.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 DelegatedAddSceneResponseCallback + implements ChipClusters.ScenesCluster.AddSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetSceneMembershipResponseCallback + implements ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, + Integer capacity, + Integer groupId, + Integer sceneCount, + ArrayList sceneList) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo capacityResponseValue = new CommandResponseInfo("capacity", "Integer"); + responseValues.put(capacityResponseValue, capacity); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneCountResponseValue = + new CommandResponseInfo("sceneCount", "Integer"); + responseValues.put(sceneCountResponseValue, sceneCount); + // sceneList: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveAllScenesResponseCallback + implements ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedRemoveSceneResponseCallback + implements ChipClusters.ScenesCluster.RemoveSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedStoreSceneResponseCallback + implements ChipClusters.ScenesCluster.StoreSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, Integer groupId, Integer sceneId) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedViewSceneResponseCallback + implements ChipClusters.ScenesCluster.ViewSceneResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer status, + Integer groupId, + Integer sceneId, + Integer transitionTime, + String sceneName, + ArrayList extensionFieldSets) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo groupIdResponseValue = new CommandResponseInfo("groupId", "Integer"); + responseValues.put(groupIdResponseValue, groupId); + CommandResponseInfo sceneIdResponseValue = new CommandResponseInfo("sceneId", "Integer"); + responseValues.put(sceneIdResponseValue, sceneId); + CommandResponseInfo transitionTimeResponseValue = + new CommandResponseInfo("transitionTime", "Integer"); + responseValues.put(transitionTimeResponseValue, transitionTime); + CommandResponseInfo sceneNameResponseValue = new CommandResponseInfo("sceneName", "String"); + responseValues.put(sceneNameResponseValue, sceneName); + // extensionFieldSets: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedScenesClusterAttributeListAttributeCallback + implements ChipClusters.ScenesCluster.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 DelegatedSoftwareDiagnosticsClusterThreadMetricsAttributeCallback + implements ChipClusters.SoftwareDiagnosticsCluster.ThreadMetricsAttributeCallback, + 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 DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.SoftwareDiagnosticsCluster.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 DelegatedSwitchClusterAttributeListAttributeCallback + implements ChipClusters.SwitchCluster.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 DelegatedNavigateTargetResponseCallback + implements ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer status, String data) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo statusResponseValue = new CommandResponseInfo("status", "Integer"); + responseValues.put(statusResponseValue, status); + CommandResponseInfo dataResponseValue = new CommandResponseInfo("data", "String"); + responseValues.put(dataResponseValue, data); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback + implements ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback, + 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 DelegatedTargetNavigatorClusterAttributeListAttributeCallback + implements ChipClusters.TargetNavigatorCluster.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 DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback + implements ChipClusters.TemperatureMeasurementCluster.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 DelegatedBooleanResponseCallback + implements ChipClusters.TestClusterCluster.BooleanResponseCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Boolean value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Boolean"); + responseValues.put(valueResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedSimpleStructResponseCallback + implements ChipClusters.TestClusterCluster.SimpleStructResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ChipStructs.TestClusterClusterSimpleStruct arg1) { + Map responseValues = new LinkedHashMap<>(); + // arg1: Struct SimpleStruct + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestAddArgumentsResponseCallback + implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer returnValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo returnValueResponseValue = + new CommandResponseInfo("returnValue", "Integer"); + responseValues.put(returnValueResponseValue, returnValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestEmitTestEventResponseCallback + implements ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Long value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo valueResponseValue = new CommandResponseInfo("value", "Long"); + responseValues.put(valueResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestEnumsResponseCallback + implements ChipClusters.TestClusterCluster.TestEnumsResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer arg1, Integer arg2) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo arg1ResponseValue = new CommandResponseInfo("arg1", "Integer"); + responseValues.put(arg1ResponseValue, arg1); + CommandResponseInfo arg2ResponseValue = new CommandResponseInfo("arg2", "Integer"); + responseValues.put(arg2ResponseValue, arg2); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestListInt8UReverseResponseCallback + implements ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(ArrayList arg1) { + Map responseValues = new LinkedHashMap<>(); + // arg1: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestNullableOptionalResponseCallback + implements ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Boolean wasPresent, + Optional wasNull, + Optional value, + @Nullable Optional originalValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo wasPresentResponseValue = + new CommandResponseInfo("wasPresent", "Boolean"); + responseValues.put(wasPresentResponseValue, wasPresent); + CommandResponseInfo wasNullResponseValue = + new CommandResponseInfo("wasNull", "Optional"); + responseValues.put(wasNullResponseValue, wasNull); + CommandResponseInfo valueResponseValue = + new CommandResponseInfo("value", "Optional"); + responseValues.put(valueResponseValue, value); + CommandResponseInfo originalValueResponseValue = + new CommandResponseInfo("originalValue", "Optional"); + responseValues.put(originalValueResponseValue, originalValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestSpecificResponseCallback + implements ChipClusters.TestClusterCluster.TestSpecificResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(Integer returnValue) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo returnValueResponseValue = + new CommandResponseInfo("returnValue", "Integer"); + responseValues.put(returnValueResponseValue, returnValue); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedTestClusterClusterListInt8uAttributeCallback + implements ChipClusters.TestClusterCluster.ListInt8uAttributeCallback, + 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 DelegatedTestClusterClusterListOctetStringAttributeCallback + implements ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback, + 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 DelegatedTestClusterClusterListStructOctetStringAttributeCallback + implements ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback, + 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 DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback + implements ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback, + 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 DelegatedTestClusterClusterListLongOctetStringAttributeCallback + implements ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback, + 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 DelegatedTestClusterClusterAttributeListAttributeCallback + implements ChipClusters.TestClusterCluster.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 DelegatedGetRelayStatusLogResponseCallback + implements ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer timeOfDay, + Integer relayStatus, + Integer localTemperature, + Integer humidityInPercentage, + Integer setpoint, + Integer unreadEntries) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo timeOfDayResponseValue = new CommandResponseInfo("timeOfDay", "Integer"); + responseValues.put(timeOfDayResponseValue, timeOfDay); + CommandResponseInfo relayStatusResponseValue = + new CommandResponseInfo("relayStatus", "Integer"); + responseValues.put(relayStatusResponseValue, relayStatus); + CommandResponseInfo localTemperatureResponseValue = + new CommandResponseInfo("localTemperature", "Integer"); + responseValues.put(localTemperatureResponseValue, localTemperature); + CommandResponseInfo humidityInPercentageResponseValue = + new CommandResponseInfo("humidityInPercentage", "Integer"); + responseValues.put(humidityInPercentageResponseValue, humidityInPercentage); + CommandResponseInfo setpointResponseValue = new CommandResponseInfo("setpoint", "Integer"); + responseValues.put(setpointResponseValue, setpoint); + CommandResponseInfo unreadEntriesResponseValue = + new CommandResponseInfo("unreadEntries", "Integer"); + responseValues.put(unreadEntriesResponseValue, unreadEntries); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedGetWeeklyScheduleResponseCallback + implements ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( + Integer numberOfTransitionsForSequence, + Integer dayOfWeekForSequence, + Integer modeForSequence, + ArrayList payload) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo numberOfTransitionsForSequenceResponseValue = + new CommandResponseInfo("numberOfTransitionsForSequence", "Integer"); + responseValues.put( + numberOfTransitionsForSequenceResponseValue, numberOfTransitionsForSequence); + CommandResponseInfo dayOfWeekForSequenceResponseValue = + new CommandResponseInfo("dayOfWeekForSequence", "Integer"); + responseValues.put(dayOfWeekForSequenceResponseValue, dayOfWeekForSequence); + CommandResponseInfo modeForSequenceResponseValue = + new CommandResponseInfo("modeForSequence", "Integer"); + responseValues.put(modeForSequenceResponseValue, modeForSequence); + // payload: /* TYPE WARNING: array array defaults to */ uint8_t * + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedThermostatClusterAttributeListAttributeCallback + implements ChipClusters.ThermostatCluster.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 DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback + implements ChipClusters.ThermostatUserInterfaceConfigurationCluster + .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 DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster + .OperationalDatasetComponentsAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster + .ActiveNetworkFaultsListAttributeCallback, + 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 DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.ThreadNetworkDiagnosticsCluster.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 DelegatedTimeFormatLocalizationClusterSupportedCalendarTypesAttributeCallback + implements ChipClusters.TimeFormatLocalizationCluster.SupportedCalendarTypesAttributeCallback, + 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 DelegatedUserLabelClusterLabelListAttributeCallback + implements ChipClusters.UserLabelCluster.LabelListAttributeCallback, + 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 DelegatedWakeOnLanClusterAttributeListAttributeCallback + implements ChipClusters.WakeOnLanCluster.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 DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback + implements ChipClusters.WiFiNetworkDiagnosticsCluster.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 DelegatedWindowCoveringClusterAttributeListAttributeCallback + implements ChipClusters.WindowCoveringCluster.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 Map getClusterMap() { + Map clusterMap = initializeClusterMap(); + Map> commandMap = getCommandMap(); + combineCommand(clusterMap, commandMap); + Map> readAttributeMap = + new ClusterReadMapping().getReadAttributeMap(); + combineCommand(clusterMap, readAttributeMap); + Map> writeAttributeMap = + new ClusterWriteMapping().getWriteAttributeMap(); + combineCommand(clusterMap, writeAttributeMap); + return clusterMap; + } + + public Map initializeClusterMap() { + Map clusterMap = new HashMap<>(); + ClusterInfo accessControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AccessControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("accessControl", accessControlClusterInfo); + ClusterInfo accountLoginClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AccountLoginCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("accountLogin", accountLoginClusterInfo); + ClusterInfo administratorCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.AdministratorCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("administratorCommissioning", administratorCommissioningClusterInfo); + ClusterInfo applicationBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("applicationBasic", applicationBasicClusterInfo); + ClusterInfo applicationLauncherClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ApplicationLauncherCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("applicationLauncher", applicationLauncherClusterInfo); + ClusterInfo audioOutputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.AudioOutputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("audioOutput", audioOutputClusterInfo); + ClusterInfo barrierControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BarrierControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("barrierControl", barrierControlClusterInfo); + ClusterInfo basicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BasicCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("basic", basicClusterInfo); + ClusterInfo binaryInputBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BinaryInputBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("binaryInputBasic", binaryInputBasicClusterInfo); + ClusterInfo bindingClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BindingCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("binding", bindingClusterInfo); + ClusterInfo booleanStateClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BooleanStateCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("booleanState", booleanStateClusterInfo); + ClusterInfo bridgedActionsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedActionsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("bridgedActions", bridgedActionsClusterInfo); + ClusterInfo bridgedDeviceBasicClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.BridgedDeviceBasicCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInfo); + ClusterInfo channelClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ChannelCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("channel", channelClusterInfo); + ClusterInfo colorControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ColorControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("colorControl", colorControlClusterInfo); + ClusterInfo contentLauncherClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ContentLauncherCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("contentLauncher", contentLauncherClusterInfo); + ClusterInfo descriptorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DescriptorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("descriptor", descriptorClusterInfo); + ClusterInfo diagnosticLogsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DiagnosticLogsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("diagnosticLogs", diagnosticLogsClusterInfo); + ClusterInfo doorLockClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.DoorLockCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("doorLock", doorLockClusterInfo); + ClusterInfo electricalMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ElectricalMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("electricalMeasurement", electricalMeasurementClusterInfo); + ClusterInfo ethernetNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.EthernetNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInfo); + ClusterInfo fixedLabelClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FixedLabelCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("fixedLabel", fixedLabelClusterInfo); + ClusterInfo flowMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.FlowMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("flowMeasurement", flowMeasurementClusterInfo); + ClusterInfo generalCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("generalCommissioning", generalCommissioningClusterInfo); + ClusterInfo generalDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GeneralDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("generalDiagnostics", generalDiagnosticsClusterInfo); + ClusterInfo groupKeyManagementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupKeyManagementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("groupKeyManagement", groupKeyManagementClusterInfo); + ClusterInfo groupsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.GroupsCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("groups", groupsClusterInfo); + ClusterInfo identifyClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IdentifyCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("identify", identifyClusterInfo); + ClusterInfo illuminanceMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.IlluminanceMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInfo); + ClusterInfo keypadInputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.KeypadInputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("keypadInput", keypadInputClusterInfo); + ClusterInfo levelControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LevelControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("levelControl", levelControlClusterInfo); + ClusterInfo localizationConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LocalizationConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("localizationConfiguration", localizationConfigurationClusterInfo); + ClusterInfo lowPowerClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.LowPowerCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("lowPower", lowPowerClusterInfo); + ClusterInfo mediaInputClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaInputCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("mediaInput", mediaInputClusterInfo); + ClusterInfo mediaPlaybackClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.MediaPlaybackCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("mediaPlayback", mediaPlaybackClusterInfo); + ClusterInfo modeSelectClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ModeSelectCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("modeSelect", modeSelectClusterInfo); + ClusterInfo networkCommissioningClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.NetworkCommissioningCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("networkCommissioning", networkCommissioningClusterInfo); + ClusterInfo otaSoftwareUpdateProviderClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OtaSoftwareUpdateProviderCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInfo); + ClusterInfo otaSoftwareUpdateRequestorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.OtaSoftwareUpdateRequestorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInfo); + ClusterInfo occupancySensingClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OccupancySensingCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("occupancySensing", occupancySensingClusterInfo); + ClusterInfo onOffClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("onOff", onOffClusterInfo); + ClusterInfo onOffSwitchConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OnOffSwitchConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInfo); + ClusterInfo operationalCredentialsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.OperationalCredentialsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("operationalCredentials", operationalCredentialsClusterInfo); + ClusterInfo powerSourceClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PowerSourceCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("powerSource", powerSourceClusterInfo); + ClusterInfo powerSourceConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PowerSourceConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInfo); + ClusterInfo pressureMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.PressureMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("pressureMeasurement", pressureMeasurementClusterInfo); + ClusterInfo pumpConfigurationAndControlClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.PumpConfigurationAndControlCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("pumpConfigurationAndControl", pumpConfigurationAndControlClusterInfo); + ClusterInfo relativeHumidityMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.RelativeHumidityMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("relativeHumidityMeasurement", relativeHumidityMeasurementClusterInfo); + ClusterInfo scenesClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ScenesCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("scenes", scenesClusterInfo); + ClusterInfo softwareDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SoftwareDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("softwareDiagnostics", softwareDiagnosticsClusterInfo); + ClusterInfo switchClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.SwitchCluster(ptr, endpointId), new HashMap<>()); + clusterMap.put("switch", switchClusterInfo); + ClusterInfo targetNavigatorClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TargetNavigatorCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("targetNavigator", targetNavigatorClusterInfo); + ClusterInfo temperatureMeasurementClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TemperatureMeasurementCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("temperatureMeasurement", temperatureMeasurementClusterInfo); + ClusterInfo testClusterClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TestClusterCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("testCluster", testClusterClusterInfo); + ClusterInfo thermostatClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThermostatCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("thermostat", thermostatClusterInfo); + ClusterInfo thermostatUserInterfaceConfigurationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> + new ChipClusters.ThermostatUserInterfaceConfigurationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put( + "thermostatUserInterfaceConfiguration", thermostatUserInterfaceConfigurationClusterInfo); + ClusterInfo threadNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.ThreadNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInfo); + ClusterInfo timeFormatLocalizationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.TimeFormatLocalizationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("timeFormatLocalization", timeFormatLocalizationClusterInfo); + ClusterInfo unitLocalizationClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.UnitLocalizationCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("unitLocalization", unitLocalizationClusterInfo); + ClusterInfo userLabelClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.UserLabelCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("userLabel", userLabelClusterInfo); + ClusterInfo wakeOnLanClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WakeOnLanCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("wakeOnLan", wakeOnLanClusterInfo); + ClusterInfo wiFiNetworkDiagnosticsClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WiFiNetworkDiagnosticsCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInfo); + ClusterInfo windowCoveringClusterInfo = + new ClusterInfo( + (ptr, endpointId) -> new ChipClusters.WindowCoveringCluster(ptr, endpointId), + new HashMap<>()); + clusterMap.put("windowCovering", windowCoveringClusterInfo); + return clusterMap; + } + + public void combineCommand( + Map destination, Map> source) { + destination.get("accessControl").combineCommands(source.get("accessControl")); + destination.get("accountLogin").combineCommands(source.get("accountLogin")); + destination + .get("administratorCommissioning") + .combineCommands(source.get("administratorCommissioning")); + destination.get("applicationBasic").combineCommands(source.get("applicationBasic")); + destination.get("applicationLauncher").combineCommands(source.get("applicationLauncher")); + destination.get("audioOutput").combineCommands(source.get("audioOutput")); + destination.get("barrierControl").combineCommands(source.get("barrierControl")); + destination.get("basic").combineCommands(source.get("basic")); + destination.get("binaryInputBasic").combineCommands(source.get("binaryInputBasic")); + destination.get("binding").combineCommands(source.get("binding")); + destination.get("booleanState").combineCommands(source.get("booleanState")); + destination.get("bridgedActions").combineCommands(source.get("bridgedActions")); + destination.get("bridgedDeviceBasic").combineCommands(source.get("bridgedDeviceBasic")); + destination.get("channel").combineCommands(source.get("channel")); + destination.get("colorControl").combineCommands(source.get("colorControl")); + destination.get("contentLauncher").combineCommands(source.get("contentLauncher")); + destination.get("descriptor").combineCommands(source.get("descriptor")); + destination.get("diagnosticLogs").combineCommands(source.get("diagnosticLogs")); + destination.get("doorLock").combineCommands(source.get("doorLock")); + destination.get("electricalMeasurement").combineCommands(source.get("electricalMeasurement")); + destination + .get("ethernetNetworkDiagnostics") + .combineCommands(source.get("ethernetNetworkDiagnostics")); + destination.get("fixedLabel").combineCommands(source.get("fixedLabel")); + destination.get("flowMeasurement").combineCommands(source.get("flowMeasurement")); + destination.get("generalCommissioning").combineCommands(source.get("generalCommissioning")); + destination.get("generalDiagnostics").combineCommands(source.get("generalDiagnostics")); + destination.get("groupKeyManagement").combineCommands(source.get("groupKeyManagement")); + destination.get("groups").combineCommands(source.get("groups")); + destination.get("identify").combineCommands(source.get("identify")); + destination.get("illuminanceMeasurement").combineCommands(source.get("illuminanceMeasurement")); + destination.get("keypadInput").combineCommands(source.get("keypadInput")); + destination.get("levelControl").combineCommands(source.get("levelControl")); + destination + .get("localizationConfiguration") + .combineCommands(source.get("localizationConfiguration")); + destination.get("lowPower").combineCommands(source.get("lowPower")); + destination.get("mediaInput").combineCommands(source.get("mediaInput")); + destination.get("mediaPlayback").combineCommands(source.get("mediaPlayback")); + destination.get("modeSelect").combineCommands(source.get("modeSelect")); + destination.get("networkCommissioning").combineCommands(source.get("networkCommissioning")); + destination + .get("otaSoftwareUpdateProvider") + .combineCommands(source.get("otaSoftwareUpdateProvider")); + destination + .get("otaSoftwareUpdateRequestor") + .combineCommands(source.get("otaSoftwareUpdateRequestor")); + destination.get("occupancySensing").combineCommands(source.get("occupancySensing")); + destination.get("onOff").combineCommands(source.get("onOff")); + destination + .get("onOffSwitchConfiguration") + .combineCommands(source.get("onOffSwitchConfiguration")); + destination.get("operationalCredentials").combineCommands(source.get("operationalCredentials")); + destination.get("powerSource").combineCommands(source.get("powerSource")); + destination + .get("powerSourceConfiguration") + .combineCommands(source.get("powerSourceConfiguration")); + destination.get("pressureMeasurement").combineCommands(source.get("pressureMeasurement")); + destination + .get("pumpConfigurationAndControl") + .combineCommands(source.get("pumpConfigurationAndControl")); + destination + .get("relativeHumidityMeasurement") + .combineCommands(source.get("relativeHumidityMeasurement")); + destination.get("scenes").combineCommands(source.get("scenes")); + destination.get("softwareDiagnostics").combineCommands(source.get("softwareDiagnostics")); + destination.get("switch").combineCommands(source.get("switch")); + destination.get("targetNavigator").combineCommands(source.get("targetNavigator")); + destination.get("temperatureMeasurement").combineCommands(source.get("temperatureMeasurement")); + destination.get("testCluster").combineCommands(source.get("testCluster")); + destination.get("thermostat").combineCommands(source.get("thermostat")); + destination + .get("thermostatUserInterfaceConfiguration") + .combineCommands(source.get("thermostatUserInterfaceConfiguration")); + destination + .get("threadNetworkDiagnostics") + .combineCommands(source.get("threadNetworkDiagnostics")); + destination.get("timeFormatLocalization").combineCommands(source.get("timeFormatLocalization")); + destination.get("unitLocalization").combineCommands(source.get("unitLocalization")); + destination.get("userLabel").combineCommands(source.get("userLabel")); + destination.get("wakeOnLan").combineCommands(source.get("wakeOnLan")); + destination.get("wiFiNetworkDiagnostics").combineCommands(source.get("wiFiNetworkDiagnostics")); + destination.get("windowCovering").combineCommands(source.get("windowCovering")); + } + + @SuppressWarnings("unchecked") + public Map> getCommandMap() { + Map> commandMap = new HashMap<>(); + Map accessControlClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("accessControl", accessControlClusterInteractionInfoMap); + Map accountLoginClusterInteractionInfoMap = new LinkedHashMap<>(); + Map accountLogingetSetupPINRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo = + new CommandParameterInfo("tempAccountIdentifier", String.class); + accountLogingetSetupPINRequestCommandParams.put( + "tempAccountIdentifier", + accountLogingetSetupPINRequesttempAccountIdentifierCommandParameterInfo); + + InteractionInfo accountLogingetSetupPINRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .getSetupPINRequest( + (ChipClusters.AccountLoginCluster.GetSetupPINResponseCallback) callback, + (String) commandArguments.get("tempAccountIdentifier"), + 10000); + }, + () -> new DelegatedGetSetupPINResponseCallback(), + accountLogingetSetupPINRequestCommandParams); + accountLoginClusterInteractionInfoMap.put( + "getSetupPINRequest", accountLogingetSetupPINRequestInteractionInfo); + Map accountLoginloginRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo accountLoginloginRequesttempAccountIdentifierCommandParameterInfo = + new CommandParameterInfo("tempAccountIdentifier", String.class); + accountLoginloginRequestCommandParams.put( + "tempAccountIdentifier", accountLoginloginRequesttempAccountIdentifierCommandParameterInfo); + + CommandParameterInfo accountLoginloginRequestsetupPINCommandParameterInfo = + new CommandParameterInfo("setupPIN", String.class); + accountLoginloginRequestCommandParams.put( + "setupPIN", accountLoginloginRequestsetupPINCommandParameterInfo); + + InteractionInfo accountLoginloginRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .loginRequest( + (DefaultClusterCallback) callback, + (String) commandArguments.get("tempAccountIdentifier"), + (String) commandArguments.get("setupPIN"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + accountLoginloginRequestCommandParams); + accountLoginClusterInteractionInfoMap.put( + "loginRequest", accountLoginloginRequestInteractionInfo); + Map accountLoginlogoutRequestCommandParams = + new LinkedHashMap(); + InteractionInfo accountLoginlogoutRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .logoutRequest((DefaultClusterCallback) callback, 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + accountLoginlogoutRequestCommandParams); + accountLoginClusterInteractionInfoMap.put( + "logoutRequest", accountLoginlogoutRequestInteractionInfo); + commandMap.put("accountLogin", accountLoginClusterInteractionInfoMap); + Map administratorCommissioningClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map + administratorCommissioningopenBasicCommissioningWindowCommandParams = + new LinkedHashMap(); + CommandParameterInfo + administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo = + new CommandParameterInfo("commissioningTimeout", Integer.class); + administratorCommissioningopenBasicCommissioningWindowCommandParams.put( + "commissioningTimeout", + administratorCommissioningopenBasicCommissioningWindowcommissioningTimeoutCommandParameterInfo); + + InteractionInfo administratorCommissioningopenBasicCommissioningWindowInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .openBasicCommissioningWindow( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("commissioningTimeout"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningopenBasicCommissioningWindowCommandParams); + administratorCommissioningClusterInteractionInfoMap.put( + "openBasicCommissioningWindow", + administratorCommissioningopenBasicCommissioningWindowInteractionInfo); + Map + administratorCommissioningopenCommissioningWindowCommandParams = + new LinkedHashMap(); + CommandParameterInfo + administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo = + new CommandParameterInfo("commissioningTimeout", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "commissioningTimeout", + administratorCommissioningopenCommissioningWindowcommissioningTimeoutCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo = + new CommandParameterInfo("PAKEVerifier", byte[].class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "PAKEVerifier", + administratorCommissioningopenCommissioningWindowPAKEVerifierCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo = + new CommandParameterInfo("discriminator", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "discriminator", + administratorCommissioningopenCommissioningWindowdiscriminatorCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo = + new CommandParameterInfo("iterations", Long.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "iterations", + administratorCommissioningopenCommissioningWindowiterationsCommandParameterInfo); + + CommandParameterInfo administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo = + new CommandParameterInfo("salt", byte[].class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "salt", administratorCommissioningopenCommissioningWindowsaltCommandParameterInfo); + + CommandParameterInfo + administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo = + new CommandParameterInfo("passcodeID", Integer.class); + administratorCommissioningopenCommissioningWindowCommandParams.put( + "passcodeID", + administratorCommissioningopenCommissioningWindowpasscodeIDCommandParameterInfo); + + InteractionInfo administratorCommissioningopenCommissioningWindowInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .openCommissioningWindow( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("commissioningTimeout"), + (byte[]) commandArguments.get("PAKEVerifier"), + (Integer) commandArguments.get("discriminator"), + (Long) commandArguments.get("iterations"), + (byte[]) commandArguments.get("salt"), + (Integer) commandArguments.get("passcodeID"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningopenCommissioningWindowCommandParams); + administratorCommissioningClusterInteractionInfoMap.put( + "openCommissioningWindow", + administratorCommissioningopenCommissioningWindowInteractionInfo); + Map administratorCommissioningrevokeCommissioningCommandParams = + new LinkedHashMap(); + InteractionInfo administratorCommissioningrevokeCommissioningInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .revokeCommissioning((DefaultClusterCallback) callback, 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + administratorCommissioningrevokeCommissioningCommandParams); + administratorCommissioningClusterInteractionInfoMap.put( + "revokeCommissioning", administratorCommissioningrevokeCommissioningInteractionInfo); + commandMap.put( + "administratorCommissioning", administratorCommissioningClusterInteractionInfoMap); + Map applicationBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("applicationBasic", applicationBasicClusterInteractionInfoMap); + Map applicationLauncherClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map applicationLauncherhideAppRequestCommandParams = + new LinkedHashMap(); + InteractionInfo applicationLauncherhideAppRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .hideAppRequest( + (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, + (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application")); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherhideAppRequestCommandParams); + applicationLauncherClusterInteractionInfoMap.put( + "hideAppRequest", applicationLauncherhideAppRequestInteractionInfo); + Map applicationLauncherlaunchAppRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo applicationLauncherlaunchAppRequestdataCommandParameterInfo = + new CommandParameterInfo("data", String.class); + applicationLauncherlaunchAppRequestCommandParams.put( + "data", applicationLauncherlaunchAppRequestdataCommandParameterInfo); + + InteractionInfo applicationLauncherlaunchAppRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .launchAppRequest( + (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, + (String) commandArguments.get("data"), + (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application")); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherlaunchAppRequestCommandParams); + applicationLauncherClusterInteractionInfoMap.put( + "launchAppRequest", applicationLauncherlaunchAppRequestInteractionInfo); + Map applicationLauncherstopAppRequestCommandParams = + new LinkedHashMap(); + InteractionInfo applicationLauncherstopAppRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .stopAppRequest( + (ChipClusters.ApplicationLauncherCluster.LauncherResponseCallback) callback, + (ChipStructs.ApplicationLauncherClusterApplicationLauncherApplication) + commandArguments.get("application")); + }, + () -> new DelegatedLauncherResponseCallback(), + applicationLauncherstopAppRequestCommandParams); + applicationLauncherClusterInteractionInfoMap.put( + "stopAppRequest", applicationLauncherstopAppRequestInteractionInfo); + commandMap.put("applicationLauncher", applicationLauncherClusterInteractionInfoMap); + Map audioOutputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map audioOutputrenameOutputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo audioOutputrenameOutputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + audioOutputrenameOutputRequestCommandParams.put( + "index", audioOutputrenameOutputRequestindexCommandParameterInfo); + + CommandParameterInfo audioOutputrenameOutputRequestnameCommandParameterInfo = + new CommandParameterInfo("name", String.class); + audioOutputrenameOutputRequestCommandParams.put( + "name", audioOutputrenameOutputRequestnameCommandParameterInfo); + + InteractionInfo audioOutputrenameOutputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .renameOutputRequest( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("index"), + (String) commandArguments.get("name")); + }, + () -> new DelegatedDefaultClusterCallback(), + audioOutputrenameOutputRequestCommandParams); + audioOutputClusterInteractionInfoMap.put( + "renameOutputRequest", audioOutputrenameOutputRequestInteractionInfo); + Map audioOutputselectOutputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo audioOutputselectOutputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + audioOutputselectOutputRequestCommandParams.put( + "index", audioOutputselectOutputRequestindexCommandParameterInfo); + + InteractionInfo audioOutputselectOutputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .selectOutputRequest( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("index")); + }, + () -> new DelegatedDefaultClusterCallback(), + audioOutputselectOutputRequestCommandParams); + audioOutputClusterInteractionInfoMap.put( + "selectOutputRequest", audioOutputselectOutputRequestInteractionInfo); + commandMap.put("audioOutput", audioOutputClusterInteractionInfoMap); + Map barrierControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map barrierControlbarrierControlGoToPercentCommandParams = + new LinkedHashMap(); + CommandParameterInfo barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo = + new CommandParameterInfo("percentOpen", Integer.class); + barrierControlbarrierControlGoToPercentCommandParams.put( + "percentOpen", barrierControlbarrierControlGoToPercentpercentOpenCommandParameterInfo); + + InteractionInfo barrierControlbarrierControlGoToPercentInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .barrierControlGoToPercent( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("percentOpen")); + }, + () -> new DelegatedDefaultClusterCallback(), + barrierControlbarrierControlGoToPercentCommandParams); + barrierControlClusterInteractionInfoMap.put( + "barrierControlGoToPercent", barrierControlbarrierControlGoToPercentInteractionInfo); + Map barrierControlbarrierControlStopCommandParams = + new LinkedHashMap(); + InteractionInfo barrierControlbarrierControlStopInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .barrierControlStop((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + barrierControlbarrierControlStopCommandParams); + barrierControlClusterInteractionInfoMap.put( + "barrierControlStop", barrierControlbarrierControlStopInteractionInfo); + commandMap.put("barrierControl", barrierControlClusterInteractionInfoMap); + Map basicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("basic", basicClusterInteractionInfoMap); + Map binaryInputBasicClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("binaryInputBasic", binaryInputBasicClusterInteractionInfoMap); + Map bindingClusterInteractionInfoMap = new LinkedHashMap<>(); + Map bindingbindCommandParams = + new LinkedHashMap(); + CommandParameterInfo bindingbindnodeIdCommandParameterInfo = + new CommandParameterInfo("nodeId", Long.class); + bindingbindCommandParams.put("nodeId", bindingbindnodeIdCommandParameterInfo); + + CommandParameterInfo bindingbindgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + bindingbindCommandParams.put("groupId", bindingbindgroupIdCommandParameterInfo); + + CommandParameterInfo bindingbindendpointIdCommandParameterInfo = + new CommandParameterInfo("endpointId", Integer.class); + bindingbindCommandParams.put("endpointId", bindingbindendpointIdCommandParameterInfo); + + CommandParameterInfo bindingbindclusterIdCommandParameterInfo = + new CommandParameterInfo("clusterId", Long.class); + bindingbindCommandParams.put("clusterId", bindingbindclusterIdCommandParameterInfo); + + InteractionInfo bindingbindInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .bind( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("nodeId"), + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("endpointId"), + (Long) commandArguments.get("clusterId")); + }, + () -> new DelegatedDefaultClusterCallback(), + bindingbindCommandParams); + bindingClusterInteractionInfoMap.put("bind", bindingbindInteractionInfo); + Map bindingunbindCommandParams = + new LinkedHashMap(); + CommandParameterInfo bindingunbindnodeIdCommandParameterInfo = + new CommandParameterInfo("nodeId", Long.class); + bindingunbindCommandParams.put("nodeId", bindingunbindnodeIdCommandParameterInfo); + + CommandParameterInfo bindingunbindgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + bindingunbindCommandParams.put("groupId", bindingunbindgroupIdCommandParameterInfo); + + CommandParameterInfo bindingunbindendpointIdCommandParameterInfo = + new CommandParameterInfo("endpointId", Integer.class); + bindingunbindCommandParams.put("endpointId", bindingunbindendpointIdCommandParameterInfo); + + CommandParameterInfo bindingunbindclusterIdCommandParameterInfo = + new CommandParameterInfo("clusterId", Long.class); + bindingunbindCommandParams.put("clusterId", bindingunbindclusterIdCommandParameterInfo); + + InteractionInfo bindingunbindInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .unbind( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("nodeId"), + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("endpointId"), + (Long) commandArguments.get("clusterId")); + }, + () -> new DelegatedDefaultClusterCallback(), + bindingunbindCommandParams); + bindingClusterInteractionInfoMap.put("unbind", bindingunbindInteractionInfo); + commandMap.put("binding", bindingClusterInteractionInfoMap); + Map booleanStateClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("booleanState", booleanStateClusterInteractionInfoMap); + Map bridgedActionsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map bridgedActionsdisableActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsdisableActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsdisableActionCommandParams.put( + "actionID", bridgedActionsdisableActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsdisableActionCommandParams.put( + "invokeID", bridgedActionsdisableActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsdisableActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .disableAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsdisableActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "disableAction", bridgedActionsdisableActionInteractionInfo); + Map bridgedActionsdisableActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsdisableActionWithDurationCommandParams.put( + "actionID", bridgedActionsdisableActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsdisableActionWithDurationCommandParams.put( + "invokeID", bridgedActionsdisableActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsdisableActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionsdisableActionWithDurationCommandParams.put( + "duration", bridgedActionsdisableActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsdisableActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .disableActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsdisableActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "disableActionWithDuration", bridgedActionsdisableActionWithDurationInteractionInfo); + Map bridgedActionsenableActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsenableActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsenableActionCommandParams.put( + "actionID", bridgedActionsenableActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsenableActionCommandParams.put( + "invokeID", bridgedActionsenableActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsenableActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .enableAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsenableActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "enableAction", bridgedActionsenableActionInteractionInfo); + Map bridgedActionsenableActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsenableActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsenableActionWithDurationCommandParams.put( + "actionID", bridgedActionsenableActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsenableActionWithDurationCommandParams.put( + "invokeID", bridgedActionsenableActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsenableActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionsenableActionWithDurationCommandParams.put( + "duration", bridgedActionsenableActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsenableActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .enableActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsenableActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "enableActionWithDuration", bridgedActionsenableActionWithDurationInteractionInfo); + Map bridgedActionsinstantActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsinstantActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsinstantActionCommandParams.put( + "actionID", bridgedActionsinstantActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsinstantActionCommandParams.put( + "invokeID", bridgedActionsinstantActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsinstantActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .instantAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsinstantActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "instantAction", bridgedActionsinstantActionInteractionInfo); + Map bridgedActionsinstantActionWithTransitionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsinstantActionWithTransitionCommandParams.put( + "actionID", bridgedActionsinstantActionWithTransitionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsinstantActionWithTransitionCommandParams.put( + "invokeID", bridgedActionsinstantActionWithTransitioninvokeIDCommandParameterInfo); + + CommandParameterInfo + bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + bridgedActionsinstantActionWithTransitionCommandParams.put( + "transitionTime", + bridgedActionsinstantActionWithTransitiontransitionTimeCommandParameterInfo); + + InteractionInfo bridgedActionsinstantActionWithTransitionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .instantActionWithTransition( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsinstantActionWithTransitionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "instantActionWithTransition", bridgedActionsinstantActionWithTransitionInteractionInfo); + Map bridgedActionspauseActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionspauseActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionspauseActionCommandParams.put( + "actionID", bridgedActionspauseActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionspauseActionCommandParams.put( + "invokeID", bridgedActionspauseActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionspauseActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .pauseAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionspauseActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "pauseAction", bridgedActionspauseActionInteractionInfo); + Map bridgedActionspauseActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionspauseActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionspauseActionWithDurationCommandParams.put( + "actionID", bridgedActionspauseActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionspauseActionWithDurationCommandParams.put( + "invokeID", bridgedActionspauseActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionspauseActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionspauseActionWithDurationCommandParams.put( + "duration", bridgedActionspauseActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionspauseActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .pauseActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionspauseActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "pauseActionWithDuration", bridgedActionspauseActionWithDurationInteractionInfo); + Map bridgedActionsresumeActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsresumeActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsresumeActionCommandParams.put( + "actionID", bridgedActionsresumeActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsresumeActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsresumeActionCommandParams.put( + "invokeID", bridgedActionsresumeActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsresumeActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .resumeAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsresumeActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "resumeAction", bridgedActionsresumeActionInteractionInfo); + Map bridgedActionsstartActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsstartActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstartActionCommandParams.put( + "actionID", bridgedActionsstartActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstartActionCommandParams.put( + "invokeID", bridgedActionsstartActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsstartActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .startAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstartActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "startAction", bridgedActionsstartActionInteractionInfo); + Map bridgedActionsstartActionWithDurationCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsstartActionWithDurationactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstartActionWithDurationCommandParams.put( + "actionID", bridgedActionsstartActionWithDurationactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstartActionWithDurationCommandParams.put( + "invokeID", bridgedActionsstartActionWithDurationinvokeIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstartActionWithDurationdurationCommandParameterInfo = + new CommandParameterInfo("duration", Long.class); + bridgedActionsstartActionWithDurationCommandParams.put( + "duration", bridgedActionsstartActionWithDurationdurationCommandParameterInfo); + + InteractionInfo bridgedActionsstartActionWithDurationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .startActionWithDuration( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID"), + (Long) commandArguments.get("duration")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstartActionWithDurationCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "startActionWithDuration", bridgedActionsstartActionWithDurationInteractionInfo); + Map bridgedActionsstopActionCommandParams = + new LinkedHashMap(); + CommandParameterInfo bridgedActionsstopActionactionIDCommandParameterInfo = + new CommandParameterInfo("actionID", Integer.class); + bridgedActionsstopActionCommandParams.put( + "actionID", bridgedActionsstopActionactionIDCommandParameterInfo); + + CommandParameterInfo bridgedActionsstopActioninvokeIDCommandParameterInfo = + new CommandParameterInfo("invokeID", Optional.class); + bridgedActionsstopActionCommandParams.put( + "invokeID", bridgedActionsstopActioninvokeIDCommandParameterInfo); + + InteractionInfo bridgedActionsstopActionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .stopAction( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("actionID"), + (Optional) commandArguments.get("invokeID")); + }, + () -> new DelegatedDefaultClusterCallback(), + bridgedActionsstopActionCommandParams); + bridgedActionsClusterInteractionInfoMap.put( + "stopAction", bridgedActionsstopActionInteractionInfo); + commandMap.put("bridgedActions", bridgedActionsClusterInteractionInfoMap); + Map bridgedDeviceBasicClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("bridgedDeviceBasic", bridgedDeviceBasicClusterInteractionInfoMap); + Map channelClusterInteractionInfoMap = new LinkedHashMap<>(); + Map channelchangeChannelByNumberRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo = + new CommandParameterInfo("majorNumber", Integer.class); + channelchangeChannelByNumberRequestCommandParams.put( + "majorNumber", channelchangeChannelByNumberRequestmajorNumberCommandParameterInfo); + + CommandParameterInfo channelchangeChannelByNumberRequestminorNumberCommandParameterInfo = + new CommandParameterInfo("minorNumber", Integer.class); + channelchangeChannelByNumberRequestCommandParams.put( + "minorNumber", channelchangeChannelByNumberRequestminorNumberCommandParameterInfo); + + InteractionInfo channelchangeChannelByNumberRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .changeChannelByNumberRequest( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("majorNumber"), + (Integer) commandArguments.get("minorNumber")); + }, + () -> new DelegatedDefaultClusterCallback(), + channelchangeChannelByNumberRequestCommandParams); + channelClusterInteractionInfoMap.put( + "changeChannelByNumberRequest", channelchangeChannelByNumberRequestInteractionInfo); + Map channelchangeChannelRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo channelchangeChannelRequestmatchCommandParameterInfo = + new CommandParameterInfo("match", String.class); + channelchangeChannelRequestCommandParams.put( + "match", channelchangeChannelRequestmatchCommandParameterInfo); + + InteractionInfo channelchangeChannelRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .changeChannelRequest( + (ChipClusters.ChannelCluster.ChangeChannelResponseCallback) callback, + (String) commandArguments.get("match")); + }, + () -> new DelegatedChangeChannelResponseCallback(), + channelchangeChannelRequestCommandParams); + channelClusterInteractionInfoMap.put( + "changeChannelRequest", channelchangeChannelRequestInteractionInfo); + Map channelskipChannelRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo channelskipChannelRequestcountCommandParameterInfo = + new CommandParameterInfo("count", Integer.class); + channelskipChannelRequestCommandParams.put( + "count", channelskipChannelRequestcountCommandParameterInfo); + + InteractionInfo channelskipChannelRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .skipChannelRequest( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("count")); + }, + () -> new DelegatedDefaultClusterCallback(), + channelskipChannelRequestCommandParams); + channelClusterInteractionInfoMap.put( + "skipChannelRequest", channelskipChannelRequestInteractionInfo); + commandMap.put("channel", channelClusterInteractionInfoMap); + Map colorControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map colorControlcolorLoopSetCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlcolorLoopSetupdateFlagsCommandParameterInfo = + new CommandParameterInfo("updateFlags", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "updateFlags", colorControlcolorLoopSetupdateFlagsCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetactionCommandParameterInfo = + new CommandParameterInfo("action", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "action", colorControlcolorLoopSetactionCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetdirectionCommandParameterInfo = + new CommandParameterInfo("direction", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "direction", colorControlcolorLoopSetdirectionCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSettimeCommandParameterInfo = + new CommandParameterInfo("time", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "time", colorControlcolorLoopSettimeCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetstartHueCommandParameterInfo = + new CommandParameterInfo("startHue", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "startHue", colorControlcolorLoopSetstartHueCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "optionsMask", colorControlcolorLoopSetoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlcolorLoopSetoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlcolorLoopSetCommandParams.put( + "optionsOverride", colorControlcolorLoopSetoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlcolorLoopSetInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .colorLoopSet( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("updateFlags"), + (Integer) commandArguments.get("action"), + (Integer) commandArguments.get("direction"), + (Integer) commandArguments.get("time"), + (Integer) commandArguments.get("startHue"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlcolorLoopSetCommandParams); + colorControlClusterInteractionInfoMap.put( + "colorLoopSet", colorControlcolorLoopSetInteractionInfo); + Map colorControlenhancedMoveHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveHuemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "moveMode", colorControlenhancedMoveHuemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHuerateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "rate", colorControlenhancedMoveHuerateCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "optionsMask", colorControlenhancedMoveHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveHueCommandParams.put( + "optionsOverride", colorControlenhancedMoveHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveHueCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveHue", colorControlenhancedMoveHueInteractionInfo); + Map colorControlenhancedMoveToHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveToHueenhancedHueCommandParameterInfo = + new CommandParameterInfo("enhancedHue", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "enhancedHue", colorControlenhancedMoveToHueenhancedHueCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHuedirectionCommandParameterInfo = + new CommandParameterInfo("direction", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "direction", colorControlenhancedMoveToHuedirectionCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "transitionTime", colorControlenhancedMoveToHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "optionsMask", colorControlenhancedMoveToHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveToHueCommandParams.put( + "optionsOverride", colorControlenhancedMoveToHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveToHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveToHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("enhancedHue"), + (Integer) commandArguments.get("direction"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveToHueCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveToHue", colorControlenhancedMoveToHueInteractionInfo); + Map colorControlenhancedMoveToHueAndSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo = + new CommandParameterInfo("enhancedHue", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "enhancedHue", colorControlenhancedMoveToHueAndSaturationenhancedHueCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo = + new CommandParameterInfo("saturation", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "saturation", colorControlenhancedMoveToHueAndSaturationsaturationCommandParameterInfo); + + CommandParameterInfo + colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "transitionTime", + colorControlenhancedMoveToHueAndSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "optionsMask", colorControlenhancedMoveToHueAndSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo + colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedMoveToHueAndSaturationCommandParams.put( + "optionsOverride", + colorControlenhancedMoveToHueAndSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedMoveToHueAndSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedMoveToHueAndSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("enhancedHue"), + (Integer) commandArguments.get("saturation"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedMoveToHueAndSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedMoveToHueAndSaturation", + colorControlenhancedMoveToHueAndSaturationInteractionInfo); + Map colorControlenhancedStepHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlenhancedStepHuestepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "stepMode", colorControlenhancedStepHuestepModeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHuestepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "stepSize", colorControlenhancedStepHuestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "transitionTime", colorControlenhancedStepHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "optionsMask", colorControlenhancedStepHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlenhancedStepHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlenhancedStepHueCommandParams.put( + "optionsOverride", colorControlenhancedStepHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlenhancedStepHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .enhancedStepHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlenhancedStepHueCommandParams); + colorControlClusterInteractionInfoMap.put( + "enhancedStepHue", colorControlenhancedStepHueInteractionInfo); + Map colorControlmoveColorCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveColorrateXCommandParameterInfo = + new CommandParameterInfo("rateX", Integer.class); + colorControlmoveColorCommandParams.put("rateX", colorControlmoveColorrateXCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorrateYCommandParameterInfo = + new CommandParameterInfo("rateY", Integer.class); + colorControlmoveColorCommandParams.put("rateY", colorControlmoveColorrateYCommandParameterInfo); + + CommandParameterInfo colorControlmoveColoroptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveColorCommandParams.put( + "optionsMask", colorControlmoveColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveColoroptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveColorCommandParams.put( + "optionsOverride", colorControlmoveColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveColorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveColor( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("rateX"), + (Integer) commandArguments.get("rateY"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveColorCommandParams); + colorControlClusterInteractionInfoMap.put("moveColor", colorControlmoveColorInteractionInfo); + Map colorControlmoveColorTemperatureCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveColorTemperaturemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "moveMode", colorControlmoveColorTemperaturemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperaturerateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "rate", colorControlmoveColorTemperaturerateCommandParameterInfo); + + CommandParameterInfo + colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMinimum", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "colorTemperatureMinimum", + colorControlmoveColorTemperaturecolorTemperatureMinimumCommandParameterInfo); + + CommandParameterInfo + colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMaximum", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "colorTemperatureMaximum", + colorControlmoveColorTemperaturecolorTemperatureMaximumCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "optionsMask", colorControlmoveColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveColorTemperatureCommandParams.put( + "optionsOverride", colorControlmoveColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveColorTemperatureInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveColorTemperature( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("colorTemperatureMinimum"), + (Integer) commandArguments.get("colorTemperatureMaximum"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveColorTemperatureCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveColorTemperature", colorControlmoveColorTemperatureInteractionInfo); + Map colorControlmoveHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveHuemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveHueCommandParams.put( + "moveMode", colorControlmoveHuemoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveHuerateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlmoveHueCommandParams.put("rate", colorControlmoveHuerateCommandParameterInfo); + + CommandParameterInfo colorControlmoveHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveHueCommandParams.put( + "optionsMask", colorControlmoveHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveHueCommandParams.put( + "optionsOverride", colorControlmoveHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveHueCommandParams); + colorControlClusterInteractionInfoMap.put("moveHue", colorControlmoveHueInteractionInfo); + Map colorControlmoveSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveSaturationmoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + colorControlmoveSaturationCommandParams.put( + "moveMode", colorControlmoveSaturationmoveModeCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationrateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + colorControlmoveSaturationCommandParams.put( + "rate", colorControlmoveSaturationrateCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveSaturationCommandParams.put( + "optionsMask", colorControlmoveSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveSaturationCommandParams.put( + "optionsOverride", colorControlmoveSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveSaturation", colorControlmoveSaturationInteractionInfo); + Map colorControlmoveToColorCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToColorcolorXCommandParameterInfo = + new CommandParameterInfo("colorX", Integer.class); + colorControlmoveToColorCommandParams.put( + "colorX", colorControlmoveToColorcolorXCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorcolorYCommandParameterInfo = + new CommandParameterInfo("colorY", Integer.class); + colorControlmoveToColorCommandParams.put( + "colorY", colorControlmoveToColorcolorYCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColortransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToColorCommandParams.put( + "transitionTime", colorControlmoveToColortransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColoroptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToColorCommandParams.put( + "optionsMask", colorControlmoveToColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColoroptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToColorCommandParams.put( + "optionsOverride", colorControlmoveToColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToColorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToColor( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("colorX"), + (Integer) commandArguments.get("colorY"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToColorCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToColor", colorControlmoveToColorInteractionInfo); + Map colorControlmoveToColorTemperatureCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo = + new CommandParameterInfo("colorTemperature", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "colorTemperature", colorControlmoveToColorTemperaturecolorTemperatureCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "transitionTime", colorControlmoveToColorTemperaturetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "optionsMask", colorControlmoveToColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToColorTemperatureCommandParams.put( + "optionsOverride", colorControlmoveToColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToColorTemperatureInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToColorTemperature( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("colorTemperature"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToColorTemperatureCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToColorTemperature", colorControlmoveToColorTemperatureInteractionInfo); + Map colorControlmoveToHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToHuehueCommandParameterInfo = + new CommandParameterInfo("hue", Integer.class); + colorControlmoveToHueCommandParams.put("hue", colorControlmoveToHuehueCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHuedirectionCommandParameterInfo = + new CommandParameterInfo("direction", Integer.class); + colorControlmoveToHueCommandParams.put( + "direction", colorControlmoveToHuedirectionCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToHueCommandParams.put( + "transitionTime", colorControlmoveToHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToHueCommandParams.put( + "optionsMask", colorControlmoveToHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToHueCommandParams.put( + "optionsOverride", colorControlmoveToHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("hue"), + (Integer) commandArguments.get("direction"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToHueCommandParams); + colorControlClusterInteractionInfoMap.put("moveToHue", colorControlmoveToHueInteractionInfo); + Map colorControlmoveToHueAndSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToHueAndSaturationhueCommandParameterInfo = + new CommandParameterInfo("hue", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "hue", colorControlmoveToHueAndSaturationhueCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationsaturationCommandParameterInfo = + new CommandParameterInfo("saturation", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "saturation", colorControlmoveToHueAndSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "transitionTime", colorControlmoveToHueAndSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "optionsMask", colorControlmoveToHueAndSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToHueAndSaturationCommandParams.put( + "optionsOverride", colorControlmoveToHueAndSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToHueAndSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToHueAndSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("hue"), + (Integer) commandArguments.get("saturation"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToHueAndSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToHueAndSaturation", colorControlmoveToHueAndSaturationInteractionInfo); + Map colorControlmoveToSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlmoveToSaturationsaturationCommandParameterInfo = + new CommandParameterInfo("saturation", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "saturation", colorControlmoveToSaturationsaturationCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "transitionTime", colorControlmoveToSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "optionsMask", colorControlmoveToSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlmoveToSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlmoveToSaturationCommandParams.put( + "optionsOverride", colorControlmoveToSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlmoveToSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .moveToSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("saturation"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlmoveToSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "moveToSaturation", colorControlmoveToSaturationInteractionInfo); + Map colorControlstepColorCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepColorstepXCommandParameterInfo = + new CommandParameterInfo("stepX", Integer.class); + colorControlstepColorCommandParams.put("stepX", colorControlstepColorstepXCommandParameterInfo); + + CommandParameterInfo colorControlstepColorstepYCommandParameterInfo = + new CommandParameterInfo("stepY", Integer.class); + colorControlstepColorCommandParams.put("stepY", colorControlstepColorstepYCommandParameterInfo); + + CommandParameterInfo colorControlstepColortransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepColorCommandParams.put( + "transitionTime", colorControlstepColortransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepColoroptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepColorCommandParams.put( + "optionsMask", colorControlstepColoroptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepColoroptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepColorCommandParams.put( + "optionsOverride", colorControlstepColoroptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepColorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepColor( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepX"), + (Integer) commandArguments.get("stepY"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepColorCommandParams); + colorControlClusterInteractionInfoMap.put("stepColor", colorControlstepColorInteractionInfo); + Map colorControlstepColorTemperatureCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepColorTemperaturestepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "stepMode", colorControlstepColorTemperaturestepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturestepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "stepSize", colorControlstepColorTemperaturestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperaturetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "transitionTime", colorControlstepColorTemperaturetransitionTimeCommandParameterInfo); + + CommandParameterInfo + colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMinimum", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "colorTemperatureMinimum", + colorControlstepColorTemperaturecolorTemperatureMinimumCommandParameterInfo); + + CommandParameterInfo + colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo = + new CommandParameterInfo("colorTemperatureMaximum", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "colorTemperatureMaximum", + colorControlstepColorTemperaturecolorTemperatureMaximumCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperatureoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "optionsMask", colorControlstepColorTemperatureoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepColorTemperatureCommandParams.put( + "optionsOverride", colorControlstepColorTemperatureoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepColorTemperatureInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepColorTemperature( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("colorTemperatureMinimum"), + (Integer) commandArguments.get("colorTemperatureMaximum"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepColorTemperatureCommandParams); + colorControlClusterInteractionInfoMap.put( + "stepColorTemperature", colorControlstepColorTemperatureInteractionInfo); + Map colorControlstepHueCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepHuestepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlstepHueCommandParams.put( + "stepMode", colorControlstepHuestepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepHuestepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlstepHueCommandParams.put( + "stepSize", colorControlstepHuestepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepHuetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepHueCommandParams.put( + "transitionTime", colorControlstepHuetransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepHueoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepHueCommandParams.put( + "optionsMask", colorControlstepHueoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepHueoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepHueCommandParams.put( + "optionsOverride", colorControlstepHueoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepHueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepHue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepHueCommandParams); + colorControlClusterInteractionInfoMap.put("stepHue", colorControlstepHueInteractionInfo); + Map colorControlstepSaturationCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstepSaturationstepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + colorControlstepSaturationCommandParams.put( + "stepMode", colorControlstepSaturationstepModeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationstepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + colorControlstepSaturationCommandParams.put( + "stepSize", colorControlstepSaturationstepSizeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationtransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + colorControlstepSaturationCommandParams.put( + "transitionTime", colorControlstepSaturationtransitionTimeCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstepSaturationCommandParams.put( + "optionsMask", colorControlstepSaturationoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstepSaturationoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstepSaturationCommandParams.put( + "optionsOverride", colorControlstepSaturationoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstepSaturationInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stepSaturation( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstepSaturationCommandParams); + colorControlClusterInteractionInfoMap.put( + "stepSaturation", colorControlstepSaturationInteractionInfo); + Map colorControlstopMoveStepCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlstopMoveStepoptionsMaskCommandParameterInfo = + new CommandParameterInfo("optionsMask", Integer.class); + colorControlstopMoveStepCommandParams.put( + "optionsMask", colorControlstopMoveStepoptionsMaskCommandParameterInfo); + + CommandParameterInfo colorControlstopMoveStepoptionsOverrideCommandParameterInfo = + new CommandParameterInfo("optionsOverride", Integer.class); + colorControlstopMoveStepCommandParams.put( + "optionsOverride", colorControlstopMoveStepoptionsOverrideCommandParameterInfo); + + InteractionInfo colorControlstopMoveStepInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .stopMoveStep( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("optionsMask"), + (Integer) commandArguments.get("optionsOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + colorControlstopMoveStepCommandParams); + colorControlClusterInteractionInfoMap.put( + "stopMoveStep", colorControlstopMoveStepInteractionInfo); + commandMap.put("colorControl", colorControlClusterInteractionInfoMap); + Map contentLauncherClusterInteractionInfoMap = new LinkedHashMap<>(); + Map contentLauncherlaunchContentRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo contentLauncherlaunchContentRequestautoPlayCommandParameterInfo = + new CommandParameterInfo("autoPlay", Boolean.class); + contentLauncherlaunchContentRequestCommandParams.put( + "autoPlay", contentLauncherlaunchContentRequestautoPlayCommandParameterInfo); + + CommandParameterInfo contentLauncherlaunchContentRequestdataCommandParameterInfo = + new CommandParameterInfo("data", String.class); + contentLauncherlaunchContentRequestCommandParams.put( + "data", contentLauncherlaunchContentRequestdataCommandParameterInfo); + + InteractionInfo contentLauncherlaunchContentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .launchContentRequest( + (ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback, + (Boolean) commandArguments.get("autoPlay"), + (String) commandArguments.get("data"), + (ArrayList) + commandArguments.get("search")); + }, + () -> new DelegatedLaunchResponseCallback(), + contentLauncherlaunchContentRequestCommandParams); + contentLauncherClusterInteractionInfoMap.put( + "launchContentRequest", contentLauncherlaunchContentRequestInteractionInfo); + Map contentLauncherlaunchURLRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo contentLauncherlaunchURLRequestcontentURLCommandParameterInfo = + new CommandParameterInfo("contentURL", String.class); + contentLauncherlaunchURLRequestCommandParams.put( + "contentURL", contentLauncherlaunchURLRequestcontentURLCommandParameterInfo); + + CommandParameterInfo contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo = + new CommandParameterInfo("displayString", String.class); + contentLauncherlaunchURLRequestCommandParams.put( + "displayString", contentLauncherlaunchURLRequestdisplayStringCommandParameterInfo); + + InteractionInfo contentLauncherlaunchURLRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .launchURLRequest( + (ChipClusters.ContentLauncherCluster.LaunchResponseCallback) callback, + (String) commandArguments.get("contentURL"), + (String) commandArguments.get("displayString"), + (ChipStructs.ContentLauncherClusterBrandingInformation) + commandArguments.get("brandingInformation")); + }, + () -> new DelegatedLaunchResponseCallback(), + contentLauncherlaunchURLRequestCommandParams); + contentLauncherClusterInteractionInfoMap.put( + "launchURLRequest", contentLauncherlaunchURLRequestInteractionInfo); + commandMap.put("contentLauncher", contentLauncherClusterInteractionInfoMap); + Map descriptorClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("descriptor", descriptorClusterInteractionInfoMap); + Map diagnosticLogsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map diagnosticLogsretrieveLogsRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo diagnosticLogsretrieveLogsRequestintentCommandParameterInfo = + new CommandParameterInfo("intent", Integer.class); + diagnosticLogsretrieveLogsRequestCommandParams.put( + "intent", diagnosticLogsretrieveLogsRequestintentCommandParameterInfo); + + CommandParameterInfo diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo = + new CommandParameterInfo("requestedProtocol", Integer.class); + diagnosticLogsretrieveLogsRequestCommandParams.put( + "requestedProtocol", + diagnosticLogsretrieveLogsRequestrequestedProtocolCommandParameterInfo); + + CommandParameterInfo + diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo = + new CommandParameterInfo("transferFileDesignator", byte[].class); + diagnosticLogsretrieveLogsRequestCommandParams.put( + "transferFileDesignator", + diagnosticLogsretrieveLogsRequesttransferFileDesignatorCommandParameterInfo); + + InteractionInfo diagnosticLogsretrieveLogsRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .retrieveLogsRequest( + (ChipClusters.DiagnosticLogsCluster.RetrieveLogsResponseCallback) callback, + (Integer) commandArguments.get("intent"), + (Integer) commandArguments.get("requestedProtocol"), + (byte[]) commandArguments.get("transferFileDesignator")); + }, + () -> new DelegatedRetrieveLogsResponseCallback(), + diagnosticLogsretrieveLogsRequestCommandParams); + diagnosticLogsClusterInteractionInfoMap.put( + "retrieveLogsRequest", diagnosticLogsretrieveLogsRequestInteractionInfo); + commandMap.put("diagnosticLogs", diagnosticLogsClusterInteractionInfoMap); + Map doorLockClusterInteractionInfoMap = new LinkedHashMap<>(); + Map doorLockclearCredentialCommandParams = + new LinkedHashMap(); + InteractionInfo doorLockclearCredentialInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearCredential( + (DefaultClusterCallback) callback, + (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearCredentialCommandParams); + doorLockClusterInteractionInfoMap.put( + "clearCredential", doorLockclearCredentialInteractionInfo); + Map doorLockclearUserCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockclearUseruserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockclearUserCommandParams.put("userIndex", doorLockclearUseruserIndexCommandParameterInfo); + + InteractionInfo doorLockclearUserInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearUser( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("userIndex"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearUserCommandParams); + doorLockClusterInteractionInfoMap.put("clearUser", doorLockclearUserInteractionInfo); + Map doorLockclearWeekDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo = + new CommandParameterInfo("weekDayIndex", Integer.class); + doorLockclearWeekDayScheduleCommandParams.put( + "weekDayIndex", doorLockclearWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockclearWeekDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockclearWeekDayScheduleCommandParams.put( + "userIndex", doorLockclearWeekDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockclearWeekDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearWeekDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("weekDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearWeekDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "clearWeekDaySchedule", doorLockclearWeekDayScheduleInteractionInfo); + Map doorLockclearYearDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo = + new CommandParameterInfo("yearDayIndex", Integer.class); + doorLockclearYearDayScheduleCommandParams.put( + "yearDayIndex", doorLockclearYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockclearYearDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockclearYearDayScheduleCommandParams.put( + "userIndex", doorLockclearYearDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockclearYearDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .clearYearDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("yearDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockclearYearDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "clearYearDaySchedule", doorLockclearYearDayScheduleInteractionInfo); + Map doorLockgetCredentialStatusCommandParams = + new LinkedHashMap(); + InteractionInfo doorLockgetCredentialStatusInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getCredentialStatus( + (ChipClusters.DoorLockCluster.GetCredentialStatusResponseCallback) callback, + (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential")); + }, + () -> new DelegatedGetCredentialStatusResponseCallback(), + doorLockgetCredentialStatusCommandParams); + doorLockClusterInteractionInfoMap.put( + "getCredentialStatus", doorLockgetCredentialStatusInteractionInfo); + Map doorLockgetUserCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockgetUseruserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockgetUserCommandParams.put("userIndex", doorLockgetUseruserIndexCommandParameterInfo); + + InteractionInfo doorLockgetUserInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getUser( + (ChipClusters.DoorLockCluster.GetUserResponseCallback) callback, + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedGetUserResponseCallback(), + doorLockgetUserCommandParams); + doorLockClusterInteractionInfoMap.put("getUser", doorLockgetUserInteractionInfo); + Map doorLockgetWeekDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo = + new CommandParameterInfo("weekDayIndex", Integer.class); + doorLockgetWeekDayScheduleCommandParams.put( + "weekDayIndex", doorLockgetWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockgetWeekDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockgetWeekDayScheduleCommandParams.put( + "userIndex", doorLockgetWeekDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockgetWeekDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getWeekDaySchedule( + (ChipClusters.DoorLockCluster.GetWeekDayScheduleResponseCallback) callback, + (Integer) commandArguments.get("weekDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedGetWeekDayScheduleResponseCallback(), + doorLockgetWeekDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "getWeekDaySchedule", doorLockgetWeekDayScheduleInteractionInfo); + Map doorLockgetYearDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo = + new CommandParameterInfo("yearDayIndex", Integer.class); + doorLockgetYearDayScheduleCommandParams.put( + "yearDayIndex", doorLockgetYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLockgetYearDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLockgetYearDayScheduleCommandParams.put( + "userIndex", doorLockgetYearDayScheduleuserIndexCommandParameterInfo); + + InteractionInfo doorLockgetYearDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .getYearDaySchedule( + (ChipClusters.DoorLockCluster.GetYearDayScheduleResponseCallback) callback, + (Integer) commandArguments.get("yearDayIndex"), + (Integer) commandArguments.get("userIndex")); + }, + () -> new DelegatedGetYearDayScheduleResponseCallback(), + doorLockgetYearDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "getYearDaySchedule", doorLockgetYearDayScheduleInteractionInfo); + Map doorLocklockDoorCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocklockDoorpinCodeCommandParameterInfo = + new CommandParameterInfo("pinCode", Optional.class); + doorLocklockDoorCommandParams.put("pinCode", doorLocklockDoorpinCodeCommandParameterInfo); + + InteractionInfo doorLocklockDoorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .lockDoor( + (DefaultClusterCallback) callback, + (Optional) commandArguments.get("pinCode"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocklockDoorCommandParams); + doorLockClusterInteractionInfoMap.put("lockDoor", doorLocklockDoorInteractionInfo); + Map doorLocksetCredentialCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetCredentialoperationTypeCommandParameterInfo = + new CommandParameterInfo("operationType", Integer.class); + doorLocksetCredentialCommandParams.put( + "operationType", doorLocksetCredentialoperationTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialcredentialDataCommandParameterInfo = + new CommandParameterInfo("credentialData", byte[].class); + doorLocksetCredentialCommandParams.put( + "credentialData", doorLocksetCredentialcredentialDataCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetCredentialCommandParams.put( + "userIndex", doorLocksetCredentialuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserStatusCommandParameterInfo = + new CommandParameterInfo("userStatus", Integer.class); + doorLocksetCredentialCommandParams.put( + "userStatus", doorLocksetCredentialuserStatusCommandParameterInfo); + + CommandParameterInfo doorLocksetCredentialuserTypeCommandParameterInfo = + new CommandParameterInfo("userType", Integer.class); + doorLocksetCredentialCommandParams.put( + "userType", doorLocksetCredentialuserTypeCommandParameterInfo); + + InteractionInfo doorLocksetCredentialInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setCredential( + (ChipClusters.DoorLockCluster.SetCredentialResponseCallback) callback, + (Integer) commandArguments.get("operationType"), + (ChipStructs.DoorLockClusterDlCredential) commandArguments.get("credential"), + (byte[]) commandArguments.get("credentialData"), + (Integer) commandArguments.get("userIndex"), + (Integer) commandArguments.get("userStatus"), + (Integer) commandArguments.get("userType"), + 10000); + }, + () -> new DelegatedSetCredentialResponseCallback(), + doorLocksetCredentialCommandParams); + doorLockClusterInteractionInfoMap.put("setCredential", doorLocksetCredentialInteractionInfo); + Map doorLocksetUserCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetUseroperationTypeCommandParameterInfo = + new CommandParameterInfo("operationType", Integer.class); + doorLocksetUserCommandParams.put( + "operationType", doorLocksetUseroperationTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetUserCommandParams.put("userIndex", doorLocksetUseruserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserNameCommandParameterInfo = + new CommandParameterInfo("userName", String.class); + doorLocksetUserCommandParams.put("userName", doorLocksetUseruserNameCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserUniqueIdCommandParameterInfo = + new CommandParameterInfo("userUniqueId", Long.class); + doorLocksetUserCommandParams.put( + "userUniqueId", doorLocksetUseruserUniqueIdCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserStatusCommandParameterInfo = + new CommandParameterInfo("userStatus", Integer.class); + doorLocksetUserCommandParams.put("userStatus", doorLocksetUseruserStatusCommandParameterInfo); + + CommandParameterInfo doorLocksetUseruserTypeCommandParameterInfo = + new CommandParameterInfo("userType", Integer.class); + doorLocksetUserCommandParams.put("userType", doorLocksetUseruserTypeCommandParameterInfo); + + CommandParameterInfo doorLocksetUsercredentialRuleCommandParameterInfo = + new CommandParameterInfo("credentialRule", Integer.class); + doorLocksetUserCommandParams.put( + "credentialRule", doorLocksetUsercredentialRuleCommandParameterInfo); + + InteractionInfo doorLocksetUserInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setUser( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("operationType"), + (Integer) commandArguments.get("userIndex"), + (String) commandArguments.get("userName"), + (Long) commandArguments.get("userUniqueId"), + (Integer) commandArguments.get("userStatus"), + (Integer) commandArguments.get("userType"), + (Integer) commandArguments.get("credentialRule"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetUserCommandParams); + doorLockClusterInteractionInfoMap.put("setUser", doorLocksetUserInteractionInfo); + Map doorLocksetWeekDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo = + new CommandParameterInfo("weekDayIndex", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "weekDayIndex", doorLocksetWeekDayScheduleweekDayIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "userIndex", doorLocksetWeekDayScheduleuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduledaysMaskCommandParameterInfo = + new CommandParameterInfo("daysMask", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "daysMask", doorLocksetWeekDayScheduledaysMaskCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDaySchedulestartHourCommandParameterInfo = + new CommandParameterInfo("startHour", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "startHour", doorLocksetWeekDaySchedulestartHourCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo = + new CommandParameterInfo("startMinute", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "startMinute", doorLocksetWeekDaySchedulestartMinuteCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleendHourCommandParameterInfo = + new CommandParameterInfo("endHour", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "endHour", doorLocksetWeekDayScheduleendHourCommandParameterInfo); + + CommandParameterInfo doorLocksetWeekDayScheduleendMinuteCommandParameterInfo = + new CommandParameterInfo("endMinute", Integer.class); + doorLocksetWeekDayScheduleCommandParams.put( + "endMinute", doorLocksetWeekDayScheduleendMinuteCommandParameterInfo); + + InteractionInfo doorLocksetWeekDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setWeekDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("weekDayIndex"), + (Integer) commandArguments.get("userIndex"), + (Integer) commandArguments.get("daysMask"), + (Integer) commandArguments.get("startHour"), + (Integer) commandArguments.get("startMinute"), + (Integer) commandArguments.get("endHour"), + (Integer) commandArguments.get("endMinute")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetWeekDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "setWeekDaySchedule", doorLocksetWeekDayScheduleInteractionInfo); + Map doorLocksetYearDayScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo = + new CommandParameterInfo("yearDayIndex", Integer.class); + doorLocksetYearDayScheduleCommandParams.put( + "yearDayIndex", doorLocksetYearDayScheduleyearDayIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDayScheduleuserIndexCommandParameterInfo = + new CommandParameterInfo("userIndex", Integer.class); + doorLocksetYearDayScheduleCommandParams.put( + "userIndex", doorLocksetYearDayScheduleuserIndexCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo = + new CommandParameterInfo("localStartTime", Long.class); + doorLocksetYearDayScheduleCommandParams.put( + "localStartTime", doorLocksetYearDaySchedulelocalStartTimeCommandParameterInfo); + + CommandParameterInfo doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo = + new CommandParameterInfo("localEndTime", Long.class); + doorLocksetYearDayScheduleCommandParams.put( + "localEndTime", doorLocksetYearDaySchedulelocalEndTimeCommandParameterInfo); + + InteractionInfo doorLocksetYearDayScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .setYearDaySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("yearDayIndex"), + (Integer) commandArguments.get("userIndex"), + (Long) commandArguments.get("localStartTime"), + (Long) commandArguments.get("localEndTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLocksetYearDayScheduleCommandParams); + doorLockClusterInteractionInfoMap.put( + "setYearDaySchedule", doorLocksetYearDayScheduleInteractionInfo); + Map doorLockunlockDoorCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockunlockDoorpinCodeCommandParameterInfo = + new CommandParameterInfo("pinCode", Optional.class); + doorLockunlockDoorCommandParams.put("pinCode", doorLockunlockDoorpinCodeCommandParameterInfo); + + InteractionInfo doorLockunlockDoorInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .unlockDoor( + (DefaultClusterCallback) callback, + (Optional) commandArguments.get("pinCode"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockunlockDoorCommandParams); + doorLockClusterInteractionInfoMap.put("unlockDoor", doorLockunlockDoorInteractionInfo); + Map doorLockunlockWithTimeoutCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockunlockWithTimeouttimeoutCommandParameterInfo = + new CommandParameterInfo("timeout", Integer.class); + doorLockunlockWithTimeoutCommandParams.put( + "timeout", doorLockunlockWithTimeouttimeoutCommandParameterInfo); + + CommandParameterInfo doorLockunlockWithTimeoutpinCodeCommandParameterInfo = + new CommandParameterInfo("pinCode", Optional.class); + doorLockunlockWithTimeoutCommandParams.put( + "pinCode", doorLockunlockWithTimeoutpinCodeCommandParameterInfo); + + InteractionInfo doorLockunlockWithTimeoutInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .unlockWithTimeout( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("timeout"), + (Optional) commandArguments.get("pinCode"), + 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + doorLockunlockWithTimeoutCommandParams); + doorLockClusterInteractionInfoMap.put( + "unlockWithTimeout", doorLockunlockWithTimeoutInteractionInfo); + commandMap.put("doorLock", doorLockClusterInteractionInfoMap); + Map electricalMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("electricalMeasurement", electricalMeasurementClusterInteractionInfoMap); + Map ethernetNetworkDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map ethernetNetworkDiagnosticsresetCountsCommandParams = + new LinkedHashMap(); + InteractionInfo ethernetNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + ethernetNetworkDiagnosticsresetCountsCommandParams); + ethernetNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", ethernetNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put( + "ethernetNetworkDiagnostics", ethernetNetworkDiagnosticsClusterInteractionInfoMap); + Map fixedLabelClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("fixedLabel", fixedLabelClusterInteractionInfoMap); + Map flowMeasurementClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("flowMeasurement", flowMeasurementClusterInteractionInfoMap); + Map generalCommissioningClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map generalCommissioningarmFailSafeCommandParams = + new LinkedHashMap(); + CommandParameterInfo generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo = + new CommandParameterInfo("expiryLengthSeconds", Integer.class); + generalCommissioningarmFailSafeCommandParams.put( + "expiryLengthSeconds", + generalCommissioningarmFailSafeexpiryLengthSecondsCommandParameterInfo); + + CommandParameterInfo generalCommissioningarmFailSafebreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + generalCommissioningarmFailSafeCommandParams.put( + "breadcrumb", generalCommissioningarmFailSafebreadcrumbCommandParameterInfo); + + CommandParameterInfo generalCommissioningarmFailSafetimeoutMsCommandParameterInfo = + new CommandParameterInfo("timeoutMs", Long.class); + generalCommissioningarmFailSafeCommandParams.put( + "timeoutMs", generalCommissioningarmFailSafetimeoutMsCommandParameterInfo); + + InteractionInfo generalCommissioningarmFailSafeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .armFailSafe( + (ChipClusters.GeneralCommissioningCluster.ArmFailSafeResponseCallback) + callback, + (Integer) commandArguments.get("expiryLengthSeconds"), + (Long) commandArguments.get("breadcrumb"), + (Long) commandArguments.get("timeoutMs")); + }, + () -> new DelegatedArmFailSafeResponseCallback(), + generalCommissioningarmFailSafeCommandParams); + generalCommissioningClusterInteractionInfoMap.put( + "armFailSafe", generalCommissioningarmFailSafeInteractionInfo); + Map generalCommissioningcommissioningCompleteCommandParams = + new LinkedHashMap(); + InteractionInfo generalCommissioningcommissioningCompleteInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .commissioningComplete( + (ChipClusters.GeneralCommissioningCluster + .CommissioningCompleteResponseCallback) + callback); + }, + () -> new DelegatedCommissioningCompleteResponseCallback(), + generalCommissioningcommissioningCompleteCommandParams); + generalCommissioningClusterInteractionInfoMap.put( + "commissioningComplete", generalCommissioningcommissioningCompleteInteractionInfo); + Map generalCommissioningsetRegulatoryConfigCommandParams = + new LinkedHashMap(); + CommandParameterInfo generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo = + new CommandParameterInfo("location", Integer.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "location", generalCommissioningsetRegulatoryConfiglocationCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo = + new CommandParameterInfo("countryCode", String.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "countryCode", generalCommissioningsetRegulatoryConfigcountryCodeCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "breadcrumb", generalCommissioningsetRegulatoryConfigbreadcrumbCommandParameterInfo); + + CommandParameterInfo generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo = + new CommandParameterInfo("timeoutMs", Long.class); + generalCommissioningsetRegulatoryConfigCommandParams.put( + "timeoutMs", generalCommissioningsetRegulatoryConfigtimeoutMsCommandParameterInfo); + + InteractionInfo generalCommissioningsetRegulatoryConfigInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .setRegulatoryConfig( + (ChipClusters.GeneralCommissioningCluster.SetRegulatoryConfigResponseCallback) + callback, + (Integer) commandArguments.get("location"), + (String) commandArguments.get("countryCode"), + (Long) commandArguments.get("breadcrumb"), + (Long) commandArguments.get("timeoutMs")); + }, + () -> new DelegatedSetRegulatoryConfigResponseCallback(), + generalCommissioningsetRegulatoryConfigCommandParams); + generalCommissioningClusterInteractionInfoMap.put( + "setRegulatoryConfig", generalCommissioningsetRegulatoryConfigInteractionInfo); + commandMap.put("generalCommissioning", generalCommissioningClusterInteractionInfoMap); + Map generalDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("generalDiagnostics", generalDiagnosticsClusterInteractionInfoMap); + Map groupKeyManagementClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map groupKeyManagementkeySetReadCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo = + new CommandParameterInfo("groupKeySetID", Integer.class); + groupKeyManagementkeySetReadCommandParams.put( + "groupKeySetID", groupKeyManagementkeySetReadgroupKeySetIDCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetReadInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetRead( + (ChipClusters.GroupKeyManagementCluster.KeySetReadResponseCallback) callback, + (Integer) commandArguments.get("groupKeySetID")); + }, + () -> new DelegatedKeySetReadResponseCallback(), + groupKeyManagementkeySetReadCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetRead", groupKeyManagementkeySetReadInteractionInfo); + Map groupKeyManagementkeySetReadAllIndicesCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo = + new CommandParameterInfo("groupKeySetIDs", ArrayList.class); + groupKeyManagementkeySetReadAllIndicesCommandParams.put( + "groupKeySetIDs", groupKeyManagementkeySetReadAllIndicesgroupKeySetIDsCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetReadAllIndicesInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetReadAllIndices( + (ChipClusters.GroupKeyManagementCluster.KeySetReadAllIndicesResponseCallback) + callback, + (ArrayList) commandArguments.get("groupKeySetIDs")); + }, + () -> new DelegatedKeySetReadAllIndicesResponseCallback(), + groupKeyManagementkeySetReadAllIndicesCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetReadAllIndices", groupKeyManagementkeySetReadAllIndicesInteractionInfo); + Map groupKeyManagementkeySetRemoveCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo = + new CommandParameterInfo("groupKeySetID", Integer.class); + groupKeyManagementkeySetRemoveCommandParams.put( + "groupKeySetID", groupKeyManagementkeySetRemovegroupKeySetIDCommandParameterInfo); + + InteractionInfo groupKeyManagementkeySetRemoveInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetRemove( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("groupKeySetID")); + }, + () -> new DelegatedDefaultClusterCallback(), + groupKeyManagementkeySetRemoveCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetRemove", groupKeyManagementkeySetRemoveInteractionInfo); + Map groupKeyManagementkeySetWriteCommandParams = + new LinkedHashMap(); + InteractionInfo groupKeyManagementkeySetWriteInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .keySetWrite( + (DefaultClusterCallback) callback, + (ChipStructs.GroupKeyManagementClusterGroupKeySet) + commandArguments.get("groupKeySet")); + }, + () -> new DelegatedDefaultClusterCallback(), + groupKeyManagementkeySetWriteCommandParams); + groupKeyManagementClusterInteractionInfoMap.put( + "keySetWrite", groupKeyManagementkeySetWriteInteractionInfo); + commandMap.put("groupKeyManagement", groupKeyManagementClusterInteractionInfoMap); + Map groupsClusterInteractionInfoMap = new LinkedHashMap<>(); + Map groupsaddGroupCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsaddGroupgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsaddGroupCommandParams.put("groupId", groupsaddGroupgroupIdCommandParameterInfo); + + CommandParameterInfo groupsaddGroupgroupNameCommandParameterInfo = + new CommandParameterInfo("groupName", String.class); + groupsaddGroupCommandParams.put("groupName", groupsaddGroupgroupNameCommandParameterInfo); + + InteractionInfo groupsaddGroupInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .addGroup( + (ChipClusters.GroupsCluster.AddGroupResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (String) commandArguments.get("groupName")); + }, + () -> new DelegatedAddGroupResponseCallback(), + groupsaddGroupCommandParams); + groupsClusterInteractionInfoMap.put("addGroup", groupsaddGroupInteractionInfo); + Map groupsaddGroupIfIdentifyingCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsaddGroupIfIdentifyingCommandParams.put( + "groupId", groupsaddGroupIfIdentifyinggroupIdCommandParameterInfo); + + CommandParameterInfo groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo = + new CommandParameterInfo("groupName", String.class); + groupsaddGroupIfIdentifyingCommandParams.put( + "groupName", groupsaddGroupIfIdentifyinggroupNameCommandParameterInfo); + + InteractionInfo groupsaddGroupIfIdentifyingInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .addGroupIfIdentifying( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("groupId"), + (String) commandArguments.get("groupName")); + }, + () -> new DelegatedDefaultClusterCallback(), + groupsaddGroupIfIdentifyingCommandParams); + groupsClusterInteractionInfoMap.put( + "addGroupIfIdentifying", groupsaddGroupIfIdentifyingInteractionInfo); + Map groupsgetGroupMembershipCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsgetGroupMembershipgroupListCommandParameterInfo = + new CommandParameterInfo("groupList", ArrayList.class); + groupsgetGroupMembershipCommandParams.put( + "groupList", groupsgetGroupMembershipgroupListCommandParameterInfo); + + InteractionInfo groupsgetGroupMembershipInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .getGroupMembership( + (ChipClusters.GroupsCluster.GetGroupMembershipResponseCallback) callback, + (ArrayList) commandArguments.get("groupList")); + }, + () -> new DelegatedGetGroupMembershipResponseCallback(), + groupsgetGroupMembershipCommandParams); + groupsClusterInteractionInfoMap.put( + "getGroupMembership", groupsgetGroupMembershipInteractionInfo); + Map groupsremoveAllGroupsCommandParams = + new LinkedHashMap(); + InteractionInfo groupsremoveAllGroupsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .removeAllGroups((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + groupsremoveAllGroupsCommandParams); + groupsClusterInteractionInfoMap.put("removeAllGroups", groupsremoveAllGroupsInteractionInfo); + Map groupsremoveGroupCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsremoveGroupgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsremoveGroupCommandParams.put("groupId", groupsremoveGroupgroupIdCommandParameterInfo); + + InteractionInfo groupsremoveGroupInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .removeGroup( + (ChipClusters.GroupsCluster.RemoveGroupResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedRemoveGroupResponseCallback(), + groupsremoveGroupCommandParams); + groupsClusterInteractionInfoMap.put("removeGroup", groupsremoveGroupInteractionInfo); + Map groupsviewGroupCommandParams = + new LinkedHashMap(); + CommandParameterInfo groupsviewGroupgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + groupsviewGroupCommandParams.put("groupId", groupsviewGroupgroupIdCommandParameterInfo); + + InteractionInfo groupsviewGroupInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .viewGroup( + (ChipClusters.GroupsCluster.ViewGroupResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedViewGroupResponseCallback(), + groupsviewGroupCommandParams); + groupsClusterInteractionInfoMap.put("viewGroup", groupsviewGroupInteractionInfo); + commandMap.put("groups", groupsClusterInteractionInfoMap); + Map identifyClusterInteractionInfoMap = new LinkedHashMap<>(); + Map identifyidentifyCommandParams = + new LinkedHashMap(); + CommandParameterInfo identifyidentifyidentifyTimeCommandParameterInfo = + new CommandParameterInfo("identifyTime", Integer.class); + identifyidentifyCommandParams.put( + "identifyTime", identifyidentifyidentifyTimeCommandParameterInfo); + + InteractionInfo identifyidentifyInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .identify( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("identifyTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + identifyidentifyCommandParams); + identifyClusterInteractionInfoMap.put("identify", identifyidentifyInteractionInfo); + Map identifyidentifyQueryCommandParams = + new LinkedHashMap(); + InteractionInfo identifyidentifyQueryInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .identifyQuery( + (ChipClusters.IdentifyCluster.IdentifyQueryResponseCallback) callback); + }, + () -> new DelegatedIdentifyQueryResponseCallback(), + identifyidentifyQueryCommandParams); + identifyClusterInteractionInfoMap.put("identifyQuery", identifyidentifyQueryInteractionInfo); + Map identifytriggerEffectCommandParams = + new LinkedHashMap(); + CommandParameterInfo identifytriggerEffecteffectIdentifierCommandParameterInfo = + new CommandParameterInfo("effectIdentifier", Integer.class); + identifytriggerEffectCommandParams.put( + "effectIdentifier", identifytriggerEffecteffectIdentifierCommandParameterInfo); + + CommandParameterInfo identifytriggerEffecteffectVariantCommandParameterInfo = + new CommandParameterInfo("effectVariant", Integer.class); + identifytriggerEffectCommandParams.put( + "effectVariant", identifytriggerEffecteffectVariantCommandParameterInfo); + + InteractionInfo identifytriggerEffectInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .triggerEffect( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("effectIdentifier"), + (Integer) commandArguments.get("effectVariant")); + }, + () -> new DelegatedDefaultClusterCallback(), + identifytriggerEffectCommandParams); + identifyClusterInteractionInfoMap.put("triggerEffect", identifytriggerEffectInteractionInfo); + commandMap.put("identify", identifyClusterInteractionInfoMap); + Map illuminanceMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("illuminanceMeasurement", illuminanceMeasurementClusterInteractionInfoMap); + Map keypadInputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map keypadInputsendKeyRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo keypadInputsendKeyRequestkeyCodeCommandParameterInfo = + new CommandParameterInfo("keyCode", Integer.class); + keypadInputsendKeyRequestCommandParams.put( + "keyCode", keypadInputsendKeyRequestkeyCodeCommandParameterInfo); + + InteractionInfo keypadInputsendKeyRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .sendKeyRequest( + (ChipClusters.KeypadInputCluster.SendKeyResponseCallback) callback, + (Integer) commandArguments.get("keyCode")); + }, + () -> new DelegatedSendKeyResponseCallback(), + keypadInputsendKeyRequestCommandParams); + keypadInputClusterInteractionInfoMap.put( + "sendKeyRequest", keypadInputsendKeyRequestInteractionInfo); + commandMap.put("keypadInput", keypadInputClusterInteractionInfoMap); + Map levelControlClusterInteractionInfoMap = new LinkedHashMap<>(); + Map levelControlmoveCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmovemoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + levelControlmoveCommandParams.put("moveMode", levelControlmovemoveModeCommandParameterInfo); + + CommandParameterInfo levelControlmoverateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + levelControlmoveCommandParams.put("rate", levelControlmoverateCommandParameterInfo); + + CommandParameterInfo levelControlmoveoptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlmoveCommandParams.put("optionMask", levelControlmoveoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlmoveoptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlmoveCommandParams.put( + "optionOverride", levelControlmoveoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlmoveInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .move( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate"), + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveCommandParams); + levelControlClusterInteractionInfoMap.put("move", levelControlmoveInteractionInfo); + Map levelControlmoveToLevelCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmoveToLevellevelCommandParameterInfo = + new CommandParameterInfo("level", Integer.class); + levelControlmoveToLevelCommandParams.put( + "level", levelControlmoveToLevellevelCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveltransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlmoveToLevelCommandParams.put( + "transitionTime", levelControlmoveToLeveltransitionTimeCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveloptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlmoveToLevelCommandParams.put( + "optionMask", levelControlmoveToLeveloptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLeveloptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlmoveToLevelCommandParams.put( + "optionOverride", levelControlmoveToLeveloptionOverrideCommandParameterInfo); + + InteractionInfo levelControlmoveToLevelInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveToLevel( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("level"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveToLevelCommandParams); + levelControlClusterInteractionInfoMap.put( + "moveToLevel", levelControlmoveToLevelInteractionInfo); + Map levelControlmoveToLevelWithOnOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmoveToLevelWithOnOfflevelCommandParameterInfo = + new CommandParameterInfo("level", Integer.class); + levelControlmoveToLevelWithOnOffCommandParams.put( + "level", levelControlmoveToLevelWithOnOfflevelCommandParameterInfo); + + CommandParameterInfo levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlmoveToLevelWithOnOffCommandParams.put( + "transitionTime", levelControlmoveToLevelWithOnOfftransitionTimeCommandParameterInfo); + + InteractionInfo levelControlmoveToLevelWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveToLevelWithOnOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("level"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveToLevelWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "moveToLevelWithOnOff", levelControlmoveToLevelWithOnOffInteractionInfo); + Map levelControlmoveWithOnOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlmoveWithOnOffmoveModeCommandParameterInfo = + new CommandParameterInfo("moveMode", Integer.class); + levelControlmoveWithOnOffCommandParams.put( + "moveMode", levelControlmoveWithOnOffmoveModeCommandParameterInfo); + + CommandParameterInfo levelControlmoveWithOnOffrateCommandParameterInfo = + new CommandParameterInfo("rate", Integer.class); + levelControlmoveWithOnOffCommandParams.put( + "rate", levelControlmoveWithOnOffrateCommandParameterInfo); + + InteractionInfo levelControlmoveWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .moveWithOnOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("moveMode"), + (Integer) commandArguments.get("rate")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlmoveWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "moveWithOnOff", levelControlmoveWithOnOffInteractionInfo); + Map levelControlstepCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlstepstepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + levelControlstepCommandParams.put("stepMode", levelControlstepstepModeCommandParameterInfo); + + CommandParameterInfo levelControlstepstepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + levelControlstepCommandParams.put("stepSize", levelControlstepstepSizeCommandParameterInfo); + + CommandParameterInfo levelControlsteptransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlstepCommandParams.put( + "transitionTime", levelControlsteptransitionTimeCommandParameterInfo); + + CommandParameterInfo levelControlstepoptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlstepCommandParams.put("optionMask", levelControlstepoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlstepoptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlstepCommandParams.put( + "optionOverride", levelControlstepoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlstepInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .step( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime"), + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstepCommandParams); + levelControlClusterInteractionInfoMap.put("step", levelControlstepInteractionInfo); + Map levelControlstepWithOnOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlstepWithOnOffstepModeCommandParameterInfo = + new CommandParameterInfo("stepMode", Integer.class); + levelControlstepWithOnOffCommandParams.put( + "stepMode", levelControlstepWithOnOffstepModeCommandParameterInfo); + + CommandParameterInfo levelControlstepWithOnOffstepSizeCommandParameterInfo = + new CommandParameterInfo("stepSize", Integer.class); + levelControlstepWithOnOffCommandParams.put( + "stepSize", levelControlstepWithOnOffstepSizeCommandParameterInfo); + + CommandParameterInfo levelControlstepWithOnOfftransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + levelControlstepWithOnOffCommandParams.put( + "transitionTime", levelControlstepWithOnOfftransitionTimeCommandParameterInfo); + + InteractionInfo levelControlstepWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stepWithOnOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("stepMode"), + (Integer) commandArguments.get("stepSize"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstepWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "stepWithOnOff", levelControlstepWithOnOffInteractionInfo); + Map levelControlstopCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControlstopoptionMaskCommandParameterInfo = + new CommandParameterInfo("optionMask", Integer.class); + levelControlstopCommandParams.put("optionMask", levelControlstopoptionMaskCommandParameterInfo); + + CommandParameterInfo levelControlstopoptionOverrideCommandParameterInfo = + new CommandParameterInfo("optionOverride", Integer.class); + levelControlstopCommandParams.put( + "optionOverride", levelControlstopoptionOverrideCommandParameterInfo); + + InteractionInfo levelControlstopInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stop( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("optionMask"), + (Integer) commandArguments.get("optionOverride")); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstopCommandParams); + levelControlClusterInteractionInfoMap.put("stop", levelControlstopInteractionInfo); + Map levelControlstopWithOnOffCommandParams = + new LinkedHashMap(); + InteractionInfo levelControlstopWithOnOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .stopWithOnOff((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + levelControlstopWithOnOffCommandParams); + levelControlClusterInteractionInfoMap.put( + "stopWithOnOff", levelControlstopWithOnOffInteractionInfo); + commandMap.put("levelControl", levelControlClusterInteractionInfoMap); + Map localizationConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("localizationConfiguration", localizationConfigurationClusterInteractionInfoMap); + Map lowPowerClusterInteractionInfoMap = new LinkedHashMap<>(); + Map lowPowersleepCommandParams = + new LinkedHashMap(); + InteractionInfo lowPowersleepInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster).sleep((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + lowPowersleepCommandParams); + lowPowerClusterInteractionInfoMap.put("sleep", lowPowersleepInteractionInfo); + commandMap.put("lowPower", lowPowerClusterInteractionInfoMap); + Map mediaInputClusterInteractionInfoMap = new LinkedHashMap<>(); + Map mediaInputhideInputStatusRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaInputhideInputStatusRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .hideInputStatusRequest((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputhideInputStatusRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "hideInputStatusRequest", mediaInputhideInputStatusRequestInteractionInfo); + Map mediaInputrenameInputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo mediaInputrenameInputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + mediaInputrenameInputRequestCommandParams.put( + "index", mediaInputrenameInputRequestindexCommandParameterInfo); + + CommandParameterInfo mediaInputrenameInputRequestnameCommandParameterInfo = + new CommandParameterInfo("name", String.class); + mediaInputrenameInputRequestCommandParams.put( + "name", mediaInputrenameInputRequestnameCommandParameterInfo); + + InteractionInfo mediaInputrenameInputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .renameInputRequest( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("index"), + (String) commandArguments.get("name")); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputrenameInputRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "renameInputRequest", mediaInputrenameInputRequestInteractionInfo); + Map mediaInputselectInputRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo mediaInputselectInputRequestindexCommandParameterInfo = + new CommandParameterInfo("index", Integer.class); + mediaInputselectInputRequestCommandParams.put( + "index", mediaInputselectInputRequestindexCommandParameterInfo); + + InteractionInfo mediaInputselectInputRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .selectInputRequest( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("index")); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputselectInputRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "selectInputRequest", mediaInputselectInputRequestInteractionInfo); + Map mediaInputshowInputStatusRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaInputshowInputStatusRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .showInputStatusRequest((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + mediaInputshowInputStatusRequestCommandParams); + mediaInputClusterInteractionInfoMap.put( + "showInputStatusRequest", mediaInputshowInputStatusRequestInteractionInfo); + commandMap.put("mediaInput", mediaInputClusterInteractionInfoMap); + Map mediaPlaybackClusterInteractionInfoMap = new LinkedHashMap<>(); + Map mediaPlaybackfastForwardRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackfastForwardRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .fastForwardRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackfastForwardRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "fastForwardRequest", mediaPlaybackfastForwardRequestInteractionInfo); + Map mediaPlaybacknextRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybacknextRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .nextRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybacknextRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "nextRequest", mediaPlaybacknextRequestInteractionInfo); + Map mediaPlaybackpauseRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackpauseRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .pauseRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackpauseRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "pauseRequest", mediaPlaybackpauseRequestInteractionInfo); + Map mediaPlaybackplayRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackplayRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .playRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackplayRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "playRequest", mediaPlaybackplayRequestInteractionInfo); + Map mediaPlaybackpreviousRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackpreviousRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .previousRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackpreviousRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "previousRequest", mediaPlaybackpreviousRequestInteractionInfo); + Map mediaPlaybackrewindRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackrewindRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .rewindRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackrewindRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "rewindRequest", mediaPlaybackrewindRequestInteractionInfo); + Map mediaPlaybackseekRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo mediaPlaybackseekRequestpositionCommandParameterInfo = + new CommandParameterInfo("position", Long.class); + mediaPlaybackseekRequestCommandParams.put( + "position", mediaPlaybackseekRequestpositionCommandParameterInfo); + + InteractionInfo mediaPlaybackseekRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .seekRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, + (Long) commandArguments.get("position")); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackseekRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "seekRequest", mediaPlaybackseekRequestInteractionInfo); + Map mediaPlaybackskipBackwardRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo = + new CommandParameterInfo("deltaPositionMilliseconds", Long.class); + mediaPlaybackskipBackwardRequestCommandParams.put( + "deltaPositionMilliseconds", + mediaPlaybackskipBackwardRequestdeltaPositionMillisecondsCommandParameterInfo); + + InteractionInfo mediaPlaybackskipBackwardRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .skipBackwardRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, + (Long) commandArguments.get("deltaPositionMilliseconds")); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackskipBackwardRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "skipBackwardRequest", mediaPlaybackskipBackwardRequestInteractionInfo); + Map mediaPlaybackskipForwardRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo = + new CommandParameterInfo("deltaPositionMilliseconds", Long.class); + mediaPlaybackskipForwardRequestCommandParams.put( + "deltaPositionMilliseconds", + mediaPlaybackskipForwardRequestdeltaPositionMillisecondsCommandParameterInfo); + + InteractionInfo mediaPlaybackskipForwardRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .skipForwardRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback, + (Long) commandArguments.get("deltaPositionMilliseconds")); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackskipForwardRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "skipForwardRequest", mediaPlaybackskipForwardRequestInteractionInfo); + Map mediaPlaybackstartOverRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackstartOverRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .startOverRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackstartOverRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "startOverRequest", mediaPlaybackstartOverRequestInteractionInfo); + Map mediaPlaybackstopRequestCommandParams = + new LinkedHashMap(); + InteractionInfo mediaPlaybackstopRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .stopRequest( + (ChipClusters.MediaPlaybackCluster.PlaybackResponseCallback) callback); + }, + () -> new DelegatedPlaybackResponseCallback(), + mediaPlaybackstopRequestCommandParams); + mediaPlaybackClusterInteractionInfoMap.put( + "stopRequest", mediaPlaybackstopRequestInteractionInfo); + commandMap.put("mediaPlayback", mediaPlaybackClusterInteractionInfoMap); + Map modeSelectClusterInteractionInfoMap = new LinkedHashMap<>(); + Map modeSelectchangeToModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo modeSelectchangeToModenewModeCommandParameterInfo = + new CommandParameterInfo("newMode", Integer.class); + modeSelectchangeToModeCommandParams.put( + "newMode", modeSelectchangeToModenewModeCommandParameterInfo); + + InteractionInfo modeSelectchangeToModeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .changeToMode( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("newMode")); + }, + () -> new DelegatedDefaultClusterCallback(), + modeSelectchangeToModeCommandParams); + modeSelectClusterInteractionInfoMap.put("changeToMode", modeSelectchangeToModeInteractionInfo); + commandMap.put("modeSelect", modeSelectClusterInteractionInfoMap); + Map networkCommissioningClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map networkCommissioningaddOrUpdateThreadNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo + networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo = + new CommandParameterInfo("operationalDataset", byte[].class); + networkCommissioningaddOrUpdateThreadNetworkCommandParams.put( + "operationalDataset", + networkCommissioningaddOrUpdateThreadNetworkoperationalDatasetCommandParameterInfo); + + CommandParameterInfo + networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningaddOrUpdateThreadNetworkCommandParams.put( + "breadcrumb", networkCommissioningaddOrUpdateThreadNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningaddOrUpdateThreadNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .addOrUpdateThreadNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("operationalDataset"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningaddOrUpdateThreadNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "addOrUpdateThreadNetwork", networkCommissioningaddOrUpdateThreadNetworkInteractionInfo); + Map networkCommissioningaddOrUpdateWiFiNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo = + new CommandParameterInfo("ssid", byte[].class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( + "ssid", networkCommissioningaddOrUpdateWiFiNetworkssidCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo = + new CommandParameterInfo("credentials", byte[].class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( + "credentials", networkCommissioningaddOrUpdateWiFiNetworkcredentialsCommandParameterInfo); + + CommandParameterInfo networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningaddOrUpdateWiFiNetworkCommandParams.put( + "breadcrumb", networkCommissioningaddOrUpdateWiFiNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .addOrUpdateWiFiNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("ssid"), + (byte[]) commandArguments.get("credentials"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningaddOrUpdateWiFiNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "addOrUpdateWiFiNetwork", networkCommissioningaddOrUpdateWiFiNetworkInteractionInfo); + Map networkCommissioningconnectNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningconnectNetworknetworkIDCommandParameterInfo = + new CommandParameterInfo("networkID", byte[].class); + networkCommissioningconnectNetworkCommandParams.put( + "networkID", networkCommissioningconnectNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningconnectNetworkCommandParams.put( + "breadcrumb", networkCommissioningconnectNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningconnectNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .connectNetwork( + (ChipClusters.NetworkCommissioningCluster.ConnectNetworkResponseCallback) + callback, + (byte[]) commandArguments.get("networkID"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedConnectNetworkResponseCallback(), + networkCommissioningconnectNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "connectNetwork", networkCommissioningconnectNetworkInteractionInfo); + Map networkCommissioningremoveNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningremoveNetworknetworkIDCommandParameterInfo = + new CommandParameterInfo("networkID", byte[].class); + networkCommissioningremoveNetworkCommandParams.put( + "networkID", networkCommissioningremoveNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningremoveNetworkCommandParams.put( + "breadcrumb", networkCommissioningremoveNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningremoveNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .removeNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("networkID"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningremoveNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "removeNetwork", networkCommissioningremoveNetworkInteractionInfo); + Map networkCommissioningreorderNetworkCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningreorderNetworknetworkIDCommandParameterInfo = + new CommandParameterInfo("networkID", byte[].class); + networkCommissioningreorderNetworkCommandParams.put( + "networkID", networkCommissioningreorderNetworknetworkIDCommandParameterInfo); + + CommandParameterInfo networkCommissioningreorderNetworknetworkIndexCommandParameterInfo = + new CommandParameterInfo("networkIndex", Integer.class); + networkCommissioningreorderNetworkCommandParams.put( + "networkIndex", networkCommissioningreorderNetworknetworkIndexCommandParameterInfo); + + CommandParameterInfo networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningreorderNetworkCommandParams.put( + "breadcrumb", networkCommissioningreorderNetworkbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningreorderNetworkInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .reorderNetwork( + (ChipClusters.NetworkCommissioningCluster.NetworkConfigResponseCallback) + callback, + (byte[]) commandArguments.get("networkID"), + (Integer) commandArguments.get("networkIndex"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedNetworkConfigResponseCallback(), + networkCommissioningreorderNetworkCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "reorderNetwork", networkCommissioningreorderNetworkInteractionInfo); + Map networkCommissioningscanNetworksCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioningscanNetworksssidCommandParameterInfo = + new CommandParameterInfo("ssid", byte[].class); + networkCommissioningscanNetworksCommandParams.put( + "ssid", networkCommissioningscanNetworksssidCommandParameterInfo); + + CommandParameterInfo networkCommissioningscanNetworksbreadcrumbCommandParameterInfo = + new CommandParameterInfo("breadcrumb", Long.class); + networkCommissioningscanNetworksCommandParams.put( + "breadcrumb", networkCommissioningscanNetworksbreadcrumbCommandParameterInfo); + + InteractionInfo networkCommissioningscanNetworksInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .scanNetworks( + (ChipClusters.NetworkCommissioningCluster.ScanNetworksResponseCallback) + callback, + (byte[]) commandArguments.get("ssid"), + (Long) commandArguments.get("breadcrumb")); + }, + () -> new DelegatedScanNetworksResponseCallback(), + networkCommissioningscanNetworksCommandParams); + networkCommissioningClusterInteractionInfoMap.put( + "scanNetworks", networkCommissioningscanNetworksInteractionInfo); + commandMap.put("networkCommissioning", networkCommissioningClusterInteractionInfoMap); + Map otaSoftwareUpdateProviderClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map otaSoftwareUpdateProviderapplyUpdateRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo = + new CommandParameterInfo("updateToken", byte[].class); + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put( + "updateToken", otaSoftwareUpdateProviderapplyUpdateRequestupdateTokenCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo = + new CommandParameterInfo("newVersion", Long.class); + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams.put( + "newVersion", otaSoftwareUpdateProviderapplyUpdateRequestnewVersionCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .applyUpdateRequest( + (ChipClusters.OtaSoftwareUpdateProviderCluster.ApplyUpdateResponseCallback) + callback, + (byte[]) commandArguments.get("updateToken"), + (Long) commandArguments.get("newVersion")); + }, + () -> new DelegatedApplyUpdateResponseCallback(), + otaSoftwareUpdateProviderapplyUpdateRequestCommandParams); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "applyUpdateRequest", otaSoftwareUpdateProviderapplyUpdateRequestInteractionInfo); + Map otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams = + new LinkedHashMap(); + CommandParameterInfo + otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo = + new CommandParameterInfo("updateToken", byte[].class); + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put( + "updateToken", otaSoftwareUpdateProvidernotifyUpdateAppliedupdateTokenCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo = + new CommandParameterInfo("softwareVersion", Long.class); + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams.put( + "softwareVersion", + otaSoftwareUpdateProvidernotifyUpdateAppliedsoftwareVersionCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .notifyUpdateApplied( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("updateToken"), + (Long) commandArguments.get("softwareVersion")); + }, + () -> new DelegatedDefaultClusterCallback(), + otaSoftwareUpdateProvidernotifyUpdateAppliedCommandParams); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "notifyUpdateApplied", otaSoftwareUpdateProvidernotifyUpdateAppliedInteractionInfo); + Map otaSoftwareUpdateProviderqueryImageCommandParams = + new LinkedHashMap(); + CommandParameterInfo otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo = + new CommandParameterInfo("vendorId", Integer.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "vendorId", otaSoftwareUpdateProviderqueryImagevendorIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo = + new CommandParameterInfo("productId", Integer.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "productId", otaSoftwareUpdateProviderqueryImageproductIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo = + new CommandParameterInfo("softwareVersion", Long.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "softwareVersion", otaSoftwareUpdateProviderqueryImagesoftwareVersionCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo = + new CommandParameterInfo("protocolsSupported", ArrayList.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "protocolsSupported", + otaSoftwareUpdateProviderqueryImageprotocolsSupportedCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo = + new CommandParameterInfo("hardwareVersion", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "hardwareVersion", otaSoftwareUpdateProviderqueryImagehardwareVersionCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo = + new CommandParameterInfo("location", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "location", otaSoftwareUpdateProviderqueryImagelocationCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo = + new CommandParameterInfo("requestorCanConsent", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "requestorCanConsent", + otaSoftwareUpdateProviderqueryImagerequestorCanConsentCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo = + new CommandParameterInfo("metadataForProvider", Optional.class); + otaSoftwareUpdateProviderqueryImageCommandParams.put( + "metadataForProvider", + otaSoftwareUpdateProviderqueryImagemetadataForProviderCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateProviderqueryImageInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .queryImage( + (ChipClusters.OtaSoftwareUpdateProviderCluster.QueryImageResponseCallback) + callback, + (Integer) commandArguments.get("vendorId"), + (Integer) commandArguments.get("productId"), + (Long) commandArguments.get("softwareVersion"), + (ArrayList) commandArguments.get("protocolsSupported"), + (Optional) commandArguments.get("hardwareVersion"), + (Optional) commandArguments.get("location"), + (Optional) commandArguments.get("requestorCanConsent"), + (Optional) commandArguments.get("metadataForProvider")); + }, + () -> new DelegatedQueryImageResponseCallback(), + otaSoftwareUpdateProviderqueryImageCommandParams); + otaSoftwareUpdateProviderClusterInteractionInfoMap.put( + "queryImage", otaSoftwareUpdateProviderqueryImageInteractionInfo); + commandMap.put("otaSoftwareUpdateProvider", otaSoftwareUpdateProviderClusterInteractionInfoMap); + Map otaSoftwareUpdateRequestorClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map otaSoftwareUpdateRequestorannounceOtaProviderCommandParams = + new LinkedHashMap(); + CommandParameterInfo + otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo = + new CommandParameterInfo("providerNodeId", Long.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "providerNodeId", + otaSoftwareUpdateRequestorannounceOtaProviderproviderNodeIdCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo = + new CommandParameterInfo("vendorId", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "vendorId", otaSoftwareUpdateRequestorannounceOtaProvidervendorIdCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo = + new CommandParameterInfo("announcementReason", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "announcementReason", + otaSoftwareUpdateRequestorannounceOtaProviderannouncementReasonCommandParameterInfo); + + CommandParameterInfo + otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo = + new CommandParameterInfo("metadataForNode", Optional.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "metadataForNode", + otaSoftwareUpdateRequestorannounceOtaProvidermetadataForNodeCommandParameterInfo); + + CommandParameterInfo otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo = + new CommandParameterInfo("endpoint", Integer.class); + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams.put( + "endpoint", otaSoftwareUpdateRequestorannounceOtaProviderendpointCommandParameterInfo); + + InteractionInfo otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .announceOtaProvider( + (DefaultClusterCallback) callback, + (Long) commandArguments.get("providerNodeId"), + (Integer) commandArguments.get("vendorId"), + (Integer) commandArguments.get("announcementReason"), + (Optional) commandArguments.get("metadataForNode"), + (Integer) commandArguments.get("endpoint")); + }, + () -> new DelegatedDefaultClusterCallback(), + otaSoftwareUpdateRequestorannounceOtaProviderCommandParams); + otaSoftwareUpdateRequestorClusterInteractionInfoMap.put( + "announceOtaProvider", otaSoftwareUpdateRequestorannounceOtaProviderInteractionInfo); + commandMap.put( + "otaSoftwareUpdateRequestor", otaSoftwareUpdateRequestorClusterInteractionInfoMap); + Map occupancySensingClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("occupancySensing", occupancySensingClusterInteractionInfoMap); + Map onOffClusterInteractionInfoMap = new LinkedHashMap<>(); + Map onOffoffCommandParams = + new LinkedHashMap(); + InteractionInfo onOffoffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).off((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffoffCommandParams); + onOffClusterInteractionInfoMap.put("off", onOffoffInteractionInfo); + Map onOffoffWithEffectCommandParams = + new LinkedHashMap(); + CommandParameterInfo onOffoffWithEffecteffectIdCommandParameterInfo = + new CommandParameterInfo("effectId", Integer.class); + onOffoffWithEffectCommandParams.put("effectId", onOffoffWithEffecteffectIdCommandParameterInfo); + + CommandParameterInfo onOffoffWithEffecteffectVariantCommandParameterInfo = + new CommandParameterInfo("effectVariant", Integer.class); + onOffoffWithEffectCommandParams.put( + "effectVariant", onOffoffWithEffecteffectVariantCommandParameterInfo); + + InteractionInfo onOffoffWithEffectInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .offWithEffect( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("effectId"), + (Integer) commandArguments.get("effectVariant")); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffoffWithEffectCommandParams); + onOffClusterInteractionInfoMap.put("offWithEffect", onOffoffWithEffectInteractionInfo); + Map onOffonCommandParams = + new LinkedHashMap(); + InteractionInfo onOffonInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).on((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonCommandParams); + onOffClusterInteractionInfoMap.put("on", onOffonInteractionInfo); + Map onOffonWithRecallGlobalSceneCommandParams = + new LinkedHashMap(); + InteractionInfo onOffonWithRecallGlobalSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .onWithRecallGlobalScene((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonWithRecallGlobalSceneCommandParams); + onOffClusterInteractionInfoMap.put( + "onWithRecallGlobalScene", onOffonWithRecallGlobalSceneInteractionInfo); + Map onOffonWithTimedOffCommandParams = + new LinkedHashMap(); + CommandParameterInfo onOffonWithTimedOffonOffControlCommandParameterInfo = + new CommandParameterInfo("onOffControl", Integer.class); + onOffonWithTimedOffCommandParams.put( + "onOffControl", onOffonWithTimedOffonOffControlCommandParameterInfo); + + CommandParameterInfo onOffonWithTimedOffonTimeCommandParameterInfo = + new CommandParameterInfo("onTime", Integer.class); + onOffonWithTimedOffCommandParams.put("onTime", onOffonWithTimedOffonTimeCommandParameterInfo); + + CommandParameterInfo onOffonWithTimedOffoffWaitTimeCommandParameterInfo = + new CommandParameterInfo("offWaitTime", Integer.class); + onOffonWithTimedOffCommandParams.put( + "offWaitTime", onOffonWithTimedOffoffWaitTimeCommandParameterInfo); + + InteractionInfo onOffonWithTimedOffInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .onWithTimedOff( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("onOffControl"), + (Integer) commandArguments.get("onTime"), + (Integer) commandArguments.get("offWaitTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + onOffonWithTimedOffCommandParams); + onOffClusterInteractionInfoMap.put("onWithTimedOff", onOffonWithTimedOffInteractionInfo); + Map onOfftoggleCommandParams = + new LinkedHashMap(); + InteractionInfo onOfftoggleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster).toggle((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + onOfftoggleCommandParams); + onOffClusterInteractionInfoMap.put("toggle", onOfftoggleInteractionInfo); + commandMap.put("onOff", onOffClusterInteractionInfoMap); + Map onOffSwitchConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("onOffSwitchConfiguration", onOffSwitchConfigurationClusterInteractionInfoMap); + Map operationalCredentialsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map operationalCredentialsaddNOCCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsaddNOCNOCValueCommandParameterInfo = + new CommandParameterInfo("NOCValue", byte[].class); + operationalCredentialsaddNOCCommandParams.put( + "NOCValue", operationalCredentialsaddNOCNOCValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCICACValueCommandParameterInfo = + new CommandParameterInfo("ICACValue", Optional.class); + operationalCredentialsaddNOCCommandParams.put( + "ICACValue", operationalCredentialsaddNOCICACValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCIPKValueCommandParameterInfo = + new CommandParameterInfo("IPKValue", byte[].class); + operationalCredentialsaddNOCCommandParams.put( + "IPKValue", operationalCredentialsaddNOCIPKValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo = + new CommandParameterInfo("caseAdminNode", Long.class); + operationalCredentialsaddNOCCommandParams.put( + "caseAdminNode", operationalCredentialsaddNOCcaseAdminNodeCommandParameterInfo); + + CommandParameterInfo operationalCredentialsaddNOCadminVendorIdCommandParameterInfo = + new CommandParameterInfo("adminVendorId", Integer.class); + operationalCredentialsaddNOCCommandParams.put( + "adminVendorId", operationalCredentialsaddNOCadminVendorIdCommandParameterInfo); + + InteractionInfo operationalCredentialsaddNOCInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .addNOC( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (byte[]) commandArguments.get("NOCValue"), + (Optional) commandArguments.get("ICACValue"), + (byte[]) commandArguments.get("IPKValue"), + (Long) commandArguments.get("caseAdminNode"), + (Integer) commandArguments.get("adminVendorId")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsaddNOCCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "addNOC", operationalCredentialsaddNOCInteractionInfo); + Map operationalCredentialsaddTrustedRootCertificateCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo = + new CommandParameterInfo("rootCertificate", byte[].class); + operationalCredentialsaddTrustedRootCertificateCommandParams.put( + "rootCertificate", + operationalCredentialsaddTrustedRootCertificaterootCertificateCommandParameterInfo); + + InteractionInfo operationalCredentialsaddTrustedRootCertificateInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .addTrustedRootCertificate( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("rootCertificate")); + }, + () -> new DelegatedDefaultClusterCallback(), + operationalCredentialsaddTrustedRootCertificateCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "addTrustedRootCertificate", + operationalCredentialsaddTrustedRootCertificateInteractionInfo); + Map operationalCredentialsattestationRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialsattestationRequestattestationNonceCommandParameterInfo = + new CommandParameterInfo("attestationNonce", byte[].class); + operationalCredentialsattestationRequestCommandParams.put( + "attestationNonce", + operationalCredentialsattestationRequestattestationNonceCommandParameterInfo); + + InteractionInfo operationalCredentialsattestationRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .attestationRequest( + (ChipClusters.OperationalCredentialsCluster.AttestationResponseCallback) + callback, + (byte[]) commandArguments.get("attestationNonce")); + }, + () -> new DelegatedAttestationResponseCallback(), + operationalCredentialsattestationRequestCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "attestationRequest", operationalCredentialsattestationRequestInteractionInfo); + Map operationalCredentialscertificateChainRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo = + new CommandParameterInfo("certificateType", Integer.class); + operationalCredentialscertificateChainRequestCommandParams.put( + "certificateType", + operationalCredentialscertificateChainRequestcertificateTypeCommandParameterInfo); + + InteractionInfo operationalCredentialscertificateChainRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .certificateChainRequest( + (ChipClusters.OperationalCredentialsCluster.CertificateChainResponseCallback) + callback, + (Integer) commandArguments.get("certificateType")); + }, + () -> new DelegatedCertificateChainResponseCallback(), + operationalCredentialscertificateChainRequestCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "certificateChainRequest", operationalCredentialscertificateChainRequestInteractionInfo); + Map operationalCredentialsopCSRRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo = + new CommandParameterInfo("CSRNonce", byte[].class); + operationalCredentialsopCSRRequestCommandParams.put( + "CSRNonce", operationalCredentialsopCSRRequestCSRNonceCommandParameterInfo); + + InteractionInfo operationalCredentialsopCSRRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .opCSRRequest( + (ChipClusters.OperationalCredentialsCluster.OpCSRResponseCallback) callback, + (byte[]) commandArguments.get("CSRNonce")); + }, + () -> new DelegatedOpCSRResponseCallback(), + operationalCredentialsopCSRRequestCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "opCSRRequest", operationalCredentialsopCSRRequestInteractionInfo); + Map operationalCredentialsremoveFabricCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsremoveFabricfabricIndexCommandParameterInfo = + new CommandParameterInfo("fabricIndex", Integer.class); + operationalCredentialsremoveFabricCommandParams.put( + "fabricIndex", operationalCredentialsremoveFabricfabricIndexCommandParameterInfo); + + InteractionInfo operationalCredentialsremoveFabricInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .removeFabric( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (Integer) commandArguments.get("fabricIndex")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsremoveFabricCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "removeFabric", operationalCredentialsremoveFabricInteractionInfo); + Map + operationalCredentialsremoveTrustedRootCertificateCommandParams = + new LinkedHashMap(); + CommandParameterInfo + operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo = + new CommandParameterInfo("trustedRootIdentifier", byte[].class); + operationalCredentialsremoveTrustedRootCertificateCommandParams.put( + "trustedRootIdentifier", + operationalCredentialsremoveTrustedRootCertificatetrustedRootIdentifierCommandParameterInfo); + + InteractionInfo operationalCredentialsremoveTrustedRootCertificateInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .removeTrustedRootCertificate( + (DefaultClusterCallback) callback, + (byte[]) commandArguments.get("trustedRootIdentifier")); + }, + () -> new DelegatedDefaultClusterCallback(), + operationalCredentialsremoveTrustedRootCertificateCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "removeTrustedRootCertificate", + operationalCredentialsremoveTrustedRootCertificateInteractionInfo); + Map operationalCredentialsupdateFabricLabelCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsupdateFabricLabellabelCommandParameterInfo = + new CommandParameterInfo("label", String.class); + operationalCredentialsupdateFabricLabelCommandParams.put( + "label", operationalCredentialsupdateFabricLabellabelCommandParameterInfo); + + InteractionInfo operationalCredentialsupdateFabricLabelInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .updateFabricLabel( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (String) commandArguments.get("label")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsupdateFabricLabelCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "updateFabricLabel", operationalCredentialsupdateFabricLabelInteractionInfo); + Map operationalCredentialsupdateNOCCommandParams = + new LinkedHashMap(); + CommandParameterInfo operationalCredentialsupdateNOCNOCValueCommandParameterInfo = + new CommandParameterInfo("NOCValue", byte[].class); + operationalCredentialsupdateNOCCommandParams.put( + "NOCValue", operationalCredentialsupdateNOCNOCValueCommandParameterInfo); + + CommandParameterInfo operationalCredentialsupdateNOCICACValueCommandParameterInfo = + new CommandParameterInfo("ICACValue", Optional.class); + operationalCredentialsupdateNOCCommandParams.put( + "ICACValue", operationalCredentialsupdateNOCICACValueCommandParameterInfo); + + InteractionInfo operationalCredentialsupdateNOCInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .updateNOC( + (ChipClusters.OperationalCredentialsCluster.NOCResponseCallback) callback, + (byte[]) commandArguments.get("NOCValue"), + (Optional) commandArguments.get("ICACValue")); + }, + () -> new DelegatedNOCResponseCallback(), + operationalCredentialsupdateNOCCommandParams); + operationalCredentialsClusterInteractionInfoMap.put( + "updateNOC", operationalCredentialsupdateNOCInteractionInfo); + commandMap.put("operationalCredentials", operationalCredentialsClusterInteractionInfoMap); + Map powerSourceClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("powerSource", powerSourceClusterInteractionInfoMap); + Map powerSourceConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("powerSourceConfiguration", powerSourceConfigurationClusterInteractionInfoMap); + Map pressureMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("pressureMeasurement", pressureMeasurementClusterInteractionInfoMap); + Map pumpConfigurationAndControlClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put( + "pumpConfigurationAndControl", pumpConfigurationAndControlClusterInteractionInfoMap); + Map relativeHumidityMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put( + "relativeHumidityMeasurement", relativeHumidityMeasurementClusterInteractionInfoMap); + Map scenesClusterInteractionInfoMap = new LinkedHashMap<>(); + Map scenesaddSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesaddScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesaddSceneCommandParams.put("groupId", scenesaddScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesaddScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesaddSceneCommandParams.put("sceneId", scenesaddScenesceneIdCommandParameterInfo); + + CommandParameterInfo scenesaddScenetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + scenesaddSceneCommandParams.put( + "transitionTime", scenesaddScenetransitionTimeCommandParameterInfo); + + CommandParameterInfo scenesaddScenesceneNameCommandParameterInfo = + new CommandParameterInfo("sceneName", String.class); + scenesaddSceneCommandParams.put("sceneName", scenesaddScenesceneNameCommandParameterInfo); + + InteractionInfo scenesaddSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .addScene( + (ChipClusters.ScenesCluster.AddSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId"), + (Integer) commandArguments.get("transitionTime"), + (String) commandArguments.get("sceneName"), + (ArrayList) + commandArguments.get("extensionFieldSets")); + }, + () -> new DelegatedAddSceneResponseCallback(), + scenesaddSceneCommandParams); + scenesClusterInteractionInfoMap.put("addScene", scenesaddSceneInteractionInfo); + Map scenesgetSceneMembershipCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesgetSceneMembershipgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesgetSceneMembershipCommandParams.put( + "groupId", scenesgetSceneMembershipgroupIdCommandParameterInfo); + + InteractionInfo scenesgetSceneMembershipInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .getSceneMembership( + (ChipClusters.ScenesCluster.GetSceneMembershipResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedGetSceneMembershipResponseCallback(), + scenesgetSceneMembershipCommandParams); + scenesClusterInteractionInfoMap.put( + "getSceneMembership", scenesgetSceneMembershipInteractionInfo); + Map scenesrecallSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesrecallScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesrecallSceneCommandParams.put("groupId", scenesrecallScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesrecallScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesrecallSceneCommandParams.put("sceneId", scenesrecallScenesceneIdCommandParameterInfo); + + CommandParameterInfo scenesrecallScenetransitionTimeCommandParameterInfo = + new CommandParameterInfo("transitionTime", Integer.class); + scenesrecallSceneCommandParams.put( + "transitionTime", scenesrecallScenetransitionTimeCommandParameterInfo); + + InteractionInfo scenesrecallSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .recallScene( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId"), + (Integer) commandArguments.get("transitionTime")); + }, + () -> new DelegatedDefaultClusterCallback(), + scenesrecallSceneCommandParams); + scenesClusterInteractionInfoMap.put("recallScene", scenesrecallSceneInteractionInfo); + Map scenesremoveAllScenesCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesremoveAllScenesgroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesremoveAllScenesCommandParams.put( + "groupId", scenesremoveAllScenesgroupIdCommandParameterInfo); + + InteractionInfo scenesremoveAllScenesInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .removeAllScenes( + (ChipClusters.ScenesCluster.RemoveAllScenesResponseCallback) callback, + (Integer) commandArguments.get("groupId")); + }, + () -> new DelegatedRemoveAllScenesResponseCallback(), + scenesremoveAllScenesCommandParams); + scenesClusterInteractionInfoMap.put("removeAllScenes", scenesremoveAllScenesInteractionInfo); + Map scenesremoveSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesremoveScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesremoveSceneCommandParams.put("groupId", scenesremoveScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesremoveScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesremoveSceneCommandParams.put("sceneId", scenesremoveScenesceneIdCommandParameterInfo); + + InteractionInfo scenesremoveSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .removeScene( + (ChipClusters.ScenesCluster.RemoveSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId")); + }, + () -> new DelegatedRemoveSceneResponseCallback(), + scenesremoveSceneCommandParams); + scenesClusterInteractionInfoMap.put("removeScene", scenesremoveSceneInteractionInfo); + Map scenesstoreSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesstoreScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesstoreSceneCommandParams.put("groupId", scenesstoreScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesstoreScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesstoreSceneCommandParams.put("sceneId", scenesstoreScenesceneIdCommandParameterInfo); + + InteractionInfo scenesstoreSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .storeScene( + (ChipClusters.ScenesCluster.StoreSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId")); + }, + () -> new DelegatedStoreSceneResponseCallback(), + scenesstoreSceneCommandParams); + scenesClusterInteractionInfoMap.put("storeScene", scenesstoreSceneInteractionInfo); + Map scenesviewSceneCommandParams = + new LinkedHashMap(); + CommandParameterInfo scenesviewScenegroupIdCommandParameterInfo = + new CommandParameterInfo("groupId", Integer.class); + scenesviewSceneCommandParams.put("groupId", scenesviewScenegroupIdCommandParameterInfo); + + CommandParameterInfo scenesviewScenesceneIdCommandParameterInfo = + new CommandParameterInfo("sceneId", Integer.class); + scenesviewSceneCommandParams.put("sceneId", scenesviewScenesceneIdCommandParameterInfo); + + InteractionInfo scenesviewSceneInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .viewScene( + (ChipClusters.ScenesCluster.ViewSceneResponseCallback) callback, + (Integer) commandArguments.get("groupId"), + (Integer) commandArguments.get("sceneId")); + }, + () -> new DelegatedViewSceneResponseCallback(), + scenesviewSceneCommandParams); + scenesClusterInteractionInfoMap.put("viewScene", scenesviewSceneInteractionInfo); + commandMap.put("scenes", scenesClusterInteractionInfoMap); + Map softwareDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map softwareDiagnosticsresetWatermarksCommandParams = + new LinkedHashMap(); + InteractionInfo softwareDiagnosticsresetWatermarksInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .resetWatermarks((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + softwareDiagnosticsresetWatermarksCommandParams); + softwareDiagnosticsClusterInteractionInfoMap.put( + "resetWatermarks", softwareDiagnosticsresetWatermarksInteractionInfo); + commandMap.put("softwareDiagnostics", softwareDiagnosticsClusterInteractionInfoMap); + Map switchClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("switch", switchClusterInteractionInfoMap); + Map targetNavigatorClusterInteractionInfoMap = new LinkedHashMap<>(); + Map targetNavigatornavigateTargetRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo targetNavigatornavigateTargetRequesttargetCommandParameterInfo = + new CommandParameterInfo("target", Integer.class); + targetNavigatornavigateTargetRequestCommandParams.put( + "target", targetNavigatornavigateTargetRequesttargetCommandParameterInfo); + + CommandParameterInfo targetNavigatornavigateTargetRequestdataCommandParameterInfo = + new CommandParameterInfo("data", String.class); + targetNavigatornavigateTargetRequestCommandParams.put( + "data", targetNavigatornavigateTargetRequestdataCommandParameterInfo); + + InteractionInfo targetNavigatornavigateTargetRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .navigateTargetRequest( + (ChipClusters.TargetNavigatorCluster.NavigateTargetResponseCallback) callback, + (Integer) commandArguments.get("target"), + (String) commandArguments.get("data")); + }, + () -> new DelegatedNavigateTargetResponseCallback(), + targetNavigatornavigateTargetRequestCommandParams); + targetNavigatorClusterInteractionInfoMap.put( + "navigateTargetRequest", targetNavigatornavigateTargetRequestInteractionInfo); + commandMap.put("targetNavigator", targetNavigatorClusterInteractionInfoMap); + Map temperatureMeasurementClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); + Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); + Map testClustersimpleStructEchoRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustersimpleStructEchoRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .simpleStructEchoRequest( + (ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback, + (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1")); + }, + () -> new DelegatedSimpleStructResponseCallback(), + testClustersimpleStructEchoRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "simpleStructEchoRequest", testClustersimpleStructEchoRequestInteractionInfo); + Map testClustertestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster).test((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestCommandParams); + testClusterClusterInteractionInfoMap.put("test", testClustertestInteractionInfo); + Map testClustertestAddArgumentsCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestAddArgumentsarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Integer.class); + testClustertestAddArgumentsCommandParams.put( + "arg1", testClustertestAddArgumentsarg1CommandParameterInfo); + + CommandParameterInfo testClustertestAddArgumentsarg2CommandParameterInfo = + new CommandParameterInfo("arg2", Integer.class); + testClustertestAddArgumentsCommandParams.put( + "arg2", testClustertestAddArgumentsarg2CommandParameterInfo); + + InteractionInfo testClustertestAddArgumentsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testAddArguments( + (ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback) callback, + (Integer) commandArguments.get("arg1"), + (Integer) commandArguments.get("arg2")); + }, + () -> new DelegatedTestAddArgumentsResponseCallback(), + testClustertestAddArgumentsCommandParams); + testClusterClusterInteractionInfoMap.put( + "testAddArguments", testClustertestAddArgumentsInteractionInfo); + Map testClustertestEmitTestEventRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestEmitTestEventRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Integer.class); + testClustertestEmitTestEventRequestCommandParams.put( + "arg1", testClustertestEmitTestEventRequestarg1CommandParameterInfo); + + CommandParameterInfo testClustertestEmitTestEventRequestarg2CommandParameterInfo = + new CommandParameterInfo("arg2", Integer.class); + testClustertestEmitTestEventRequestCommandParams.put( + "arg2", testClustertestEmitTestEventRequestarg2CommandParameterInfo); + + CommandParameterInfo testClustertestEmitTestEventRequestarg3CommandParameterInfo = + new CommandParameterInfo("arg3", Boolean.class); + testClustertestEmitTestEventRequestCommandParams.put( + "arg3", testClustertestEmitTestEventRequestarg3CommandParameterInfo); + + InteractionInfo testClustertestEmitTestEventRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testEmitTestEventRequest( + (ChipClusters.TestClusterCluster.TestEmitTestEventResponseCallback) callback, + (Integer) commandArguments.get("arg1"), + (Integer) commandArguments.get("arg2"), + (Boolean) commandArguments.get("arg3")); + }, + () -> new DelegatedTestEmitTestEventResponseCallback(), + testClustertestEmitTestEventRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testEmitTestEventRequest", testClustertestEmitTestEventRequestInteractionInfo); + Map testClustertestEnumsRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestEnumsRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Integer.class); + testClustertestEnumsRequestCommandParams.put( + "arg1", testClustertestEnumsRequestarg1CommandParameterInfo); + + CommandParameterInfo testClustertestEnumsRequestarg2CommandParameterInfo = + new CommandParameterInfo("arg2", Integer.class); + testClustertestEnumsRequestCommandParams.put( + "arg2", testClustertestEnumsRequestarg2CommandParameterInfo); + + InteractionInfo testClustertestEnumsRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testEnumsRequest( + (ChipClusters.TestClusterCluster.TestEnumsResponseCallback) callback, + (Integer) commandArguments.get("arg1"), + (Integer) commandArguments.get("arg2")); + }, + () -> new DelegatedTestEnumsResponseCallback(), + testClustertestEnumsRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testEnumsRequest", testClustertestEnumsRequestInteractionInfo); + Map testClustertestListInt8UArgumentRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestListInt8UArgumentRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", ArrayList.class); + testClustertestListInt8UArgumentRequestCommandParams.put( + "arg1", testClustertestListInt8UArgumentRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestListInt8UArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListInt8UArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ArrayList) commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListInt8UArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListInt8UArgumentRequest", testClustertestListInt8UArgumentRequestInteractionInfo); + Map testClustertestListInt8UReverseRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestListInt8UReverseRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", ArrayList.class); + testClustertestListInt8UReverseRequestCommandParams.put( + "arg1", testClustertestListInt8UReverseRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestListInt8UReverseRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListInt8UReverseRequest( + (ChipClusters.TestClusterCluster.TestListInt8UReverseResponseCallback) + callback, + (ArrayList) commandArguments.get("arg1")); + }, + () -> new DelegatedTestListInt8UReverseResponseCallback(), + testClustertestListInt8UReverseRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListInt8UReverseRequest", testClustertestListInt8UReverseRequestInteractionInfo); + Map + testClustertestListNestedStructListArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestListNestedStructListArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListNestedStructListArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ArrayList) + commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListNestedStructListArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListNestedStructListArgumentRequest", + testClustertestListNestedStructListArgumentRequestInteractionInfo); + Map testClustertestListStructArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testListStructArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ArrayList) + commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestListStructArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testListStructArgumentRequest", testClustertestListStructArgumentRequestInteractionInfo); + Map testClustertestNestedStructArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestNestedStructArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNestedStructArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ChipStructs.TestClusterClusterNestedStruct) commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestNestedStructArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNestedStructArgumentRequest", + testClustertestNestedStructArgumentRequestInteractionInfo); + Map testClustertestNestedStructListArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestNestedStructListArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNestedStructListArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ChipStructs.TestClusterClusterNestedStructList) + commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestNestedStructListArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNestedStructListArgumentRequest", + testClustertestNestedStructListArgumentRequestInteractionInfo); + Map testClustertestNotHandledCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestNotHandledInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNotHandled((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestNotHandledCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNotHandled", testClustertestNotHandledInteractionInfo); + Map testClustertestNullableOptionalRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestNullableOptionalRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Optional.class); + testClustertestNullableOptionalRequestCommandParams.put( + "arg1", testClustertestNullableOptionalRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestNullableOptionalRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testNullableOptionalRequest( + (ChipClusters.TestClusterCluster.TestNullableOptionalResponseCallback) + callback, + (Optional) commandArguments.get("arg1")); + }, + () -> new DelegatedTestNullableOptionalResponseCallback(), + testClustertestNullableOptionalRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testNullableOptionalRequest", testClustertestNullableOptionalRequestInteractionInfo); + Map testClustertestSimpleOptionalArgumentRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo = + new CommandParameterInfo("arg1", Optional.class); + testClustertestSimpleOptionalArgumentRequestCommandParams.put( + "arg1", testClustertestSimpleOptionalArgumentRequestarg1CommandParameterInfo); + + InteractionInfo testClustertestSimpleOptionalArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testSimpleOptionalArgumentRequest( + (DefaultClusterCallback) callback, + (Optional) commandArguments.get("arg1")); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestSimpleOptionalArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testSimpleOptionalArgumentRequest", + testClustertestSimpleOptionalArgumentRequestInteractionInfo); + Map testClustertestSpecificCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestSpecificInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testSpecific( + (ChipClusters.TestClusterCluster.TestSpecificResponseCallback) callback); + }, + () -> new DelegatedTestSpecificResponseCallback(), + testClustertestSpecificCommandParams); + testClusterClusterInteractionInfoMap.put( + "testSpecific", testClustertestSpecificInteractionInfo); + Map testClustertestStructArgumentRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestStructArgumentRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testStructArgumentRequest( + (ChipClusters.TestClusterCluster.BooleanResponseCallback) callback, + (ChipStructs.TestClusterClusterSimpleStruct) commandArguments.get("arg1")); + }, + () -> new DelegatedBooleanResponseCallback(), + testClustertestStructArgumentRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "testStructArgumentRequest", testClustertestStructArgumentRequestInteractionInfo); + Map testClustertestUnknownCommandCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertestUnknownCommandInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .testUnknownCommand((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertestUnknownCommandCommandParams); + testClusterClusterInteractionInfoMap.put( + "testUnknownCommand", testClustertestUnknownCommandInteractionInfo); + Map testClustertimedInvokeRequestCommandParams = + new LinkedHashMap(); + InteractionInfo testClustertimedInvokeRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .timedInvokeRequest((DefaultClusterCallback) callback, 10000); + }, + () -> new DelegatedDefaultClusterCallback(), + testClustertimedInvokeRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "timedInvokeRequest", testClustertimedInvokeRequestInteractionInfo); + commandMap.put("testCluster", testClusterClusterInteractionInfoMap); + Map thermostatClusterInteractionInfoMap = new LinkedHashMap<>(); + Map thermostatclearWeeklyScheduleCommandParams = + new LinkedHashMap(); + InteractionInfo thermostatclearWeeklyScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .clearWeeklySchedule((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatclearWeeklyScheduleCommandParams); + thermostatClusterInteractionInfoMap.put( + "clearWeeklySchedule", thermostatclearWeeklyScheduleInteractionInfo); + Map thermostatgetRelayStatusLogCommandParams = + new LinkedHashMap(); + InteractionInfo thermostatgetRelayStatusLogInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .getRelayStatusLog( + (ChipClusters.ThermostatCluster.GetRelayStatusLogResponseCallback) callback); + }, + () -> new DelegatedGetRelayStatusLogResponseCallback(), + thermostatgetRelayStatusLogCommandParams); + thermostatClusterInteractionInfoMap.put( + "getRelayStatusLog", thermostatgetRelayStatusLogInteractionInfo); + Map thermostatgetWeeklyScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo = + new CommandParameterInfo("daysToReturn", Integer.class); + thermostatgetWeeklyScheduleCommandParams.put( + "daysToReturn", thermostatgetWeeklyScheduledaysToReturnCommandParameterInfo); + + CommandParameterInfo thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo = + new CommandParameterInfo("modeToReturn", Integer.class); + thermostatgetWeeklyScheduleCommandParams.put( + "modeToReturn", thermostatgetWeeklySchedulemodeToReturnCommandParameterInfo); + + InteractionInfo thermostatgetWeeklyScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .getWeeklySchedule( + (ChipClusters.ThermostatCluster.GetWeeklyScheduleResponseCallback) callback, + (Integer) commandArguments.get("daysToReturn"), + (Integer) commandArguments.get("modeToReturn")); + }, + () -> new DelegatedGetWeeklyScheduleResponseCallback(), + thermostatgetWeeklyScheduleCommandParams); + thermostatClusterInteractionInfoMap.put( + "getWeeklySchedule", thermostatgetWeeklyScheduleInteractionInfo); + Map thermostatsetWeeklyScheduleCommandParams = + new LinkedHashMap(); + CommandParameterInfo + thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo = + new CommandParameterInfo("numberOfTransitionsForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put( + "numberOfTransitionsForSequence", + thermostatsetWeeklySchedulenumberOfTransitionsForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo = + new CommandParameterInfo("dayOfWeekForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put( + "dayOfWeekForSequence", + thermostatsetWeeklyScheduledayOfWeekForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo = + new CommandParameterInfo("modeForSequence", Integer.class); + thermostatsetWeeklyScheduleCommandParams.put( + "modeForSequence", thermostatsetWeeklySchedulemodeForSequenceCommandParameterInfo); + + CommandParameterInfo thermostatsetWeeklySchedulepayloadCommandParameterInfo = + new CommandParameterInfo("payload", ArrayList.class); + thermostatsetWeeklyScheduleCommandParams.put( + "payload", thermostatsetWeeklySchedulepayloadCommandParameterInfo); + + InteractionInfo thermostatsetWeeklyScheduleInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .setWeeklySchedule( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("numberOfTransitionsForSequence"), + (Integer) commandArguments.get("dayOfWeekForSequence"), + (Integer) commandArguments.get("modeForSequence"), + (ArrayList) commandArguments.get("payload")); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatsetWeeklyScheduleCommandParams); + thermostatClusterInteractionInfoMap.put( + "setWeeklySchedule", thermostatsetWeeklyScheduleInteractionInfo); + Map thermostatsetpointRaiseLowerCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatsetpointRaiseLowermodeCommandParameterInfo = + new CommandParameterInfo("mode", Integer.class); + thermostatsetpointRaiseLowerCommandParams.put( + "mode", thermostatsetpointRaiseLowermodeCommandParameterInfo); + + CommandParameterInfo thermostatsetpointRaiseLoweramountCommandParameterInfo = + new CommandParameterInfo("amount", Integer.class); + thermostatsetpointRaiseLowerCommandParams.put( + "amount", thermostatsetpointRaiseLoweramountCommandParameterInfo); + + InteractionInfo thermostatsetpointRaiseLowerInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .setpointRaiseLower( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("mode"), + (Integer) commandArguments.get("amount")); + }, + () -> new DelegatedDefaultClusterCallback(), + thermostatsetpointRaiseLowerCommandParams); + thermostatClusterInteractionInfoMap.put( + "setpointRaiseLower", thermostatsetpointRaiseLowerInteractionInfo); + commandMap.put("thermostat", thermostatClusterInteractionInfoMap); + Map thermostatUserInterfaceConfigurationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put( + "thermostatUserInterfaceConfiguration", + thermostatUserInterfaceConfigurationClusterInteractionInfoMap); + Map threadNetworkDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map threadNetworkDiagnosticsresetCountsCommandParams = + new LinkedHashMap(); + InteractionInfo threadNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + threadNetworkDiagnosticsresetCountsCommandParams); + threadNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", threadNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("threadNetworkDiagnostics", threadNetworkDiagnosticsClusterInteractionInfoMap); + Map timeFormatLocalizationClusterInteractionInfoMap = + new LinkedHashMap<>(); + commandMap.put("timeFormatLocalization", timeFormatLocalizationClusterInteractionInfoMap); + Map unitLocalizationClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("unitLocalization", unitLocalizationClusterInteractionInfoMap); + Map userLabelClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("userLabel", userLabelClusterInteractionInfoMap); + Map wakeOnLanClusterInteractionInfoMap = new LinkedHashMap<>(); + commandMap.put("wakeOnLan", wakeOnLanClusterInteractionInfoMap); + Map wiFiNetworkDiagnosticsClusterInteractionInfoMap = + new LinkedHashMap<>(); + Map wiFiNetworkDiagnosticsresetCountsCommandParams = + new LinkedHashMap(); + InteractionInfo wiFiNetworkDiagnosticsresetCountsInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .resetCounts((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + wiFiNetworkDiagnosticsresetCountsCommandParams); + wiFiNetworkDiagnosticsClusterInteractionInfoMap.put( + "resetCounts", wiFiNetworkDiagnosticsresetCountsInteractionInfo); + commandMap.put("wiFiNetworkDiagnostics", wiFiNetworkDiagnosticsClusterInteractionInfoMap); + Map windowCoveringClusterInteractionInfoMap = new LinkedHashMap<>(); + Map windowCoveringdownOrCloseCommandParams = + new LinkedHashMap(); + InteractionInfo windowCoveringdownOrCloseInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .downOrClose((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringdownOrCloseCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "downOrClose", windowCoveringdownOrCloseInteractionInfo); + Map windowCoveringgoToLiftPercentageCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo = + new CommandParameterInfo("liftPercentageValue", Integer.class); + windowCoveringgoToLiftPercentageCommandParams.put( + "liftPercentageValue", + windowCoveringgoToLiftPercentageliftPercentageValueCommandParameterInfo); + + CommandParameterInfo + windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo = + new CommandParameterInfo("liftPercent100thsValue", Integer.class); + windowCoveringgoToLiftPercentageCommandParams.put( + "liftPercent100thsValue", + windowCoveringgoToLiftPercentageliftPercent100thsValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToLiftPercentageInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToLiftPercentage( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("liftPercentageValue"), + (Integer) commandArguments.get("liftPercent100thsValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToLiftPercentageCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToLiftPercentage", windowCoveringgoToLiftPercentageInteractionInfo); + Map windowCoveringgoToLiftValueCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToLiftValueliftValueCommandParameterInfo = + new CommandParameterInfo("liftValue", Integer.class); + windowCoveringgoToLiftValueCommandParams.put( + "liftValue", windowCoveringgoToLiftValueliftValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToLiftValueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToLiftValue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("liftValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToLiftValueCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToLiftValue", windowCoveringgoToLiftValueInteractionInfo); + Map windowCoveringgoToTiltPercentageCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo = + new CommandParameterInfo("tiltPercentageValue", Integer.class); + windowCoveringgoToTiltPercentageCommandParams.put( + "tiltPercentageValue", + windowCoveringgoToTiltPercentagetiltPercentageValueCommandParameterInfo); + + CommandParameterInfo + windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo = + new CommandParameterInfo("tiltPercent100thsValue", Integer.class); + windowCoveringgoToTiltPercentageCommandParams.put( + "tiltPercent100thsValue", + windowCoveringgoToTiltPercentagetiltPercent100thsValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToTiltPercentageInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToTiltPercentage( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("tiltPercentageValue"), + (Integer) commandArguments.get("tiltPercent100thsValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToTiltPercentageCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToTiltPercentage", windowCoveringgoToTiltPercentageInteractionInfo); + Map windowCoveringgoToTiltValueCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringgoToTiltValuetiltValueCommandParameterInfo = + new CommandParameterInfo("tiltValue", Integer.class); + windowCoveringgoToTiltValueCommandParams.put( + "tiltValue", windowCoveringgoToTiltValuetiltValueCommandParameterInfo); + + InteractionInfo windowCoveringgoToTiltValueInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .goToTiltValue( + (DefaultClusterCallback) callback, + (Integer) commandArguments.get("tiltValue")); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringgoToTiltValueCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "goToTiltValue", windowCoveringgoToTiltValueInteractionInfo); + Map windowCoveringstopMotionCommandParams = + new LinkedHashMap(); + InteractionInfo windowCoveringstopMotionInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .stopMotion((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringstopMotionCommandParams); + windowCoveringClusterInteractionInfoMap.put( + "stopMotion", windowCoveringstopMotionInteractionInfo); + Map windowCoveringupOrOpenCommandParams = + new LinkedHashMap(); + InteractionInfo windowCoveringupOrOpenInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .upOrOpen((DefaultClusterCallback) callback); + }, + () -> new DelegatedDefaultClusterCallback(), + windowCoveringupOrOpenCommandParams); + windowCoveringClusterInteractionInfoMap.put("upOrOpen", windowCoveringupOrOpenInteractionInfo); + commandMap.put("windowCovering", windowCoveringClusterInteractionInfoMap); + return commandMap; + } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java index e433d2ce7db37d..2dc210109c6a96 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java @@ -29,8044 +29,8466 @@ public class ClusterReadMapping { public Map> getReadAttributeMap() { Map> readAttributeMap = new HashMap<>(); - Map readAccessControlInteractionInfo = new LinkedHashMap<>(); - Map readAccessControlAclCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlAclAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readAclAttribute( - ( ChipClusters.AccessControlCluster.AclAttributeCallback - ) callback - ); - }, + Map readAccessControlInteractionInfo = 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 - ); - readAccessControlInteractionInfo.put("readAclAttribute", readAccessControlAclAttributeInteractionInfo); - Map readAccessControlExtensionCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlExtensionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readExtensionAttribute( - ( ChipClusters.AccessControlCluster.ExtensionAttributeCallback - ) callback - ); - }, + readAccessControlAclCommandParams); + readAccessControlInteractionInfo.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 - ); - readAccessControlInteractionInfo.put("readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); - Map readAccessControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AccessControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccessControlClusterAttributeListAttributeCallback(), - readAccessControlAttributeListCommandParams - ); - readAccessControlInteractionInfo.put("readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); - Map readAccessControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccessControlCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccessControlClusterRevisionCommandParams - ); - readAccessControlInteractionInfo.put("readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("accessControl", readAccessControlInteractionInfo); - Map readAccountLoginInteractionInfo = new LinkedHashMap<>(); - Map readAccountLoginAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AccountLoginCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), - readAccountLoginAttributeListCommandParams - ); - readAccountLoginInteractionInfo.put("readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); - Map readAccountLoginClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AccountLoginCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAccountLoginClusterRevisionCommandParams - ); - readAccountLoginInteractionInfo.put("readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("accountLogin", readAccountLoginInteractionInfo); - Map readAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readAdministratorCommissioningWindowStatusCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readWindowStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningWindowStatusCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readWindowStatusAttribute", readAdministratorCommissioningWindowStatusAttributeInteractionInfo); - Map readAdministratorCommissioningAdminFabricIndexCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminFabricIndexAttribute( - ( ChipClusters.AdministratorCommissioningCluster.AdminFabricIndexAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningAdminFabricIndexCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readAdminFabricIndexAttribute", readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); - Map readAdministratorCommissioningAdminVendorIdCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAdminVendorIdAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningAdminVendorIdCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readAdminVendorIdAttribute", readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); - Map readAdministratorCommissioningAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AdministratorCommissioningCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), - readAdministratorCommissioningAttributeListCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readAttributeListAttribute", readAdministratorCommissioningAttributeListAttributeInteractionInfo); - Map readAdministratorCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AdministratorCommissioningCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAdministratorCommissioningClusterRevisionCommandParams - ); - readAdministratorCommissioningInteractionInfo.put("readClusterRevisionAttribute", readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("administratorCommissioning", readAdministratorCommissioningInteractionInfo); - Map readApplicationBasicInteractionInfo = new LinkedHashMap<>(); - Map readApplicationBasicVendorNameCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readVendorNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readAccessControlExtensionCommandParams); + readAccessControlInteractionInfo.put( + "readExtensionAttribute", readAccessControlExtensionAttributeInteractionInfo); + Map readAccessControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AccessControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAccessControlClusterAttributeListAttributeCallback(), + readAccessControlAttributeListCommandParams); + readAccessControlInteractionInfo.put( + "readAttributeListAttribute", readAccessControlAttributeListAttributeInteractionInfo); + Map readAccessControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAccessControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccessControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccessControlClusterRevisionCommandParams); + readAccessControlInteractionInfo.put( + "readClusterRevisionAttribute", readAccessControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("accessControl", readAccessControlInteractionInfo); + Map readAccountLoginInteractionInfo = new LinkedHashMap<>(); + Map readAccountLoginAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AccountLoginCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedAccountLoginClusterAttributeListAttributeCallback(), + readAccountLoginAttributeListCommandParams); + readAccountLoginInteractionInfo.put( + "readAttributeListAttribute", readAccountLoginAttributeListAttributeInteractionInfo); + Map readAccountLoginClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAccountLoginClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AccountLoginCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAccountLoginClusterRevisionCommandParams); + readAccountLoginInteractionInfo.put( + "readClusterRevisionAttribute", readAccountLoginClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("accountLogin", readAccountLoginInteractionInfo); + Map readAdministratorCommissioningInteractionInfo = + new LinkedHashMap<>(); + Map readAdministratorCommissioningWindowStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningWindowStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readWindowStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningWindowStatusCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readWindowStatusAttribute", + readAdministratorCommissioningWindowStatusAttributeInteractionInfo); + Map readAdministratorCommissioningAdminFabricIndexCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAdminFabricIndexAttribute( + (ChipClusters.AdministratorCommissioningCluster + .AdminFabricIndexAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningAdminFabricIndexCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readAdminFabricIndexAttribute", + readAdministratorCommissioningAdminFabricIndexAttributeInteractionInfo); + Map readAdministratorCommissioningAdminVendorIdCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAdminVendorIdAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningAdminVendorIdCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readAdminVendorIdAttribute", + readAdministratorCommissioningAdminVendorIdAttributeInteractionInfo); + Map readAdministratorCommissioningAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AdministratorCommissioningCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAdministratorCommissioningClusterAttributeListAttributeCallback(), + readAdministratorCommissioningAttributeListCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readAttributeListAttribute", + readAdministratorCommissioningAttributeListAttributeInteractionInfo); + Map readAdministratorCommissioningClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAdministratorCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AdministratorCommissioningCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAdministratorCommissioningClusterRevisionCommandParams); + readAdministratorCommissioningInteractionInfo.put( + "readClusterRevisionAttribute", + readAdministratorCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "administratorCommissioning", readAdministratorCommissioningInteractionInfo); + Map readApplicationBasicInteractionInfo = new LinkedHashMap<>(); + Map readApplicationBasicVendorNameCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicVendorNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicVendorNameCommandParams - ); - readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.put("readVendorIdAttribute", readApplicationBasicVendorIdAttributeInteractionInfo); - Map readApplicationBasicApplicationNameCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readApplicationBasicVendorNameCommandParams); + readApplicationBasicInteractionInfo.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); + readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.put("readProductIdAttribute", readApplicationBasicProductIdAttributeInteractionInfo); - Map readApplicationBasicApplicationStatusCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicApplicationStatusCommandParams - ); - readApplicationBasicInteractionInfo.put("readApplicationStatusAttribute", readApplicationBasicApplicationStatusAttributeInteractionInfo); - Map readApplicationBasicApplicationVersionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readApplicationVersionAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readApplicationBasicApplicationNameCommandParams); + readApplicationBasicInteractionInfo.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); + readApplicationBasicInteractionInfo.put( + "readProductIdAttribute", readApplicationBasicProductIdAttributeInteractionInfo); + Map readApplicationBasicApplicationStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readApplicationStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicApplicationStatusCommandParams); + readApplicationBasicInteractionInfo.put( + "readApplicationStatusAttribute", + readApplicationBasicApplicationStatusAttributeInteractionInfo); + Map readApplicationBasicApplicationVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicApplicationVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readApplicationVersionAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readApplicationBasicApplicationVersionCommandParams - ); - readApplicationBasicInteractionInfo.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 - ); - readApplicationBasicInteractionInfo.put("readAllowedVendorListAttribute", readApplicationBasicAllowedVendorListAttributeInteractionInfo); - Map readApplicationBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationBasicClusterAttributeListAttributeCallback(), - readApplicationBasicAttributeListCommandParams - ); - readApplicationBasicInteractionInfo.put("readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); - Map readApplicationBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationBasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationBasicClusterRevisionCommandParams - ); - readApplicationBasicInteractionInfo.put("readClusterRevisionAttribute", readApplicationBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("applicationBasic", readApplicationBasicInteractionInfo); - Map readApplicationLauncherInteractionInfo = new LinkedHashMap<>(); - Map readApplicationLauncherApplicationLauncherListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherApplicationLauncherListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readApplicationLauncherListAttribute( - ( ChipClusters.ApplicationLauncherCluster.ApplicationLauncherListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback(), - readApplicationLauncherApplicationLauncherListCommandParams - ); - readApplicationLauncherInteractionInfo.put("readApplicationLauncherListAttribute", readApplicationLauncherApplicationLauncherListAttributeInteractionInfo); - Map readApplicationLauncherAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), - readApplicationLauncherAttributeListCommandParams - ); - readApplicationLauncherInteractionInfo.put("readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); - Map readApplicationLauncherClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ApplicationLauncherCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readApplicationLauncherClusterRevisionCommandParams - ); - readApplicationLauncherInteractionInfo.put("readClusterRevisionAttribute", readApplicationLauncherClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("applicationLauncher", readApplicationLauncherInteractionInfo); - Map readAudioOutputInteractionInfo = new LinkedHashMap<>(); - Map readAudioOutputAudioOutputListCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputAudioOutputListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readAudioOutputListAttribute( - ( ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAudioOutputListAttributeCallback(), - readAudioOutputAudioOutputListCommandParams - ); - readAudioOutputInteractionInfo.put("readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeInteractionInfo); - Map readAudioOutputCurrentAudioOutputCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputCurrentAudioOutputAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readCurrentAudioOutputAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputCurrentAudioOutputCommandParams - ); - readAudioOutputInteractionInfo.put("readCurrentAudioOutputAttribute", readAudioOutputCurrentAudioOutputAttributeInteractionInfo); - Map readAudioOutputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readAttributeListAttribute( - ( ChipClusters.AudioOutputCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), - readAudioOutputAttributeListCommandParams - ); - readAudioOutputInteractionInfo.put("readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); - Map readAudioOutputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.AudioOutputCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readAudioOutputClusterRevisionCommandParams - ); - readAudioOutputInteractionInfo.put("readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("audioOutput", readAudioOutputInteractionInfo); - Map readBarrierControlInteractionInfo = new LinkedHashMap<>(); - Map readBarrierControlBarrierMovingStateCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierMovingStateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierMovingStateCommandParams - ); - readBarrierControlInteractionInfo.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 - ); - readBarrierControlInteractionInfo.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 - ); - readBarrierControlInteractionInfo.put("readBarrierCapabilitiesAttribute", readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); - Map readBarrierControlBarrierPositionCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readBarrierPositionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlBarrierPositionCommandParams - ); - readBarrierControlInteractionInfo.put("readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); - Map readBarrierControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BarrierControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBarrierControlClusterAttributeListAttributeCallback(), - readBarrierControlAttributeListCommandParams - ); - readBarrierControlInteractionInfo.put("readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); - Map readBarrierControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BarrierControlCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBarrierControlClusterRevisionCommandParams - ); - readBarrierControlInteractionInfo.put("readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("barrierControl", readBarrierControlInteractionInfo); - Map readBasicInteractionInfo = new LinkedHashMap<>(); - Map readBasicInteractionModelVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicInteractionModelVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readInteractionModelVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicInteractionModelVersionCommandParams - ); - readBasicInteractionInfo.put("readInteractionModelVersionAttribute", readBasicInteractionModelVersionAttributeInteractionInfo); - Map readBasicVendorNameCommandParams = new LinkedHashMap(); - InteractionInfo readBasicVendorNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readVendorNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readApplicationBasicApplicationVersionCommandParams); + readApplicationBasicInteractionInfo.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); + readApplicationBasicInteractionInfo.put( + "readAllowedVendorListAttribute", + readApplicationBasicAllowedVendorListAttributeInteractionInfo); + Map readApplicationBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ApplicationBasicCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationBasicClusterAttributeListAttributeCallback(), + readApplicationBasicAttributeListCommandParams); + readApplicationBasicInteractionInfo.put( + "readAttributeListAttribute", readApplicationBasicAttributeListAttributeInteractionInfo); + Map readApplicationBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationBasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationBasicClusterRevisionCommandParams); + readApplicationBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readApplicationBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationBasic", readApplicationBasicInteractionInfo); + Map readApplicationLauncherInteractionInfo = new LinkedHashMap<>(); + Map readApplicationLauncherApplicationLauncherListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherApplicationLauncherListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readApplicationLauncherListAttribute( + (ChipClusters.ApplicationLauncherCluster + .ApplicationLauncherListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationLauncherClusterApplicationLauncherListAttributeCallback(), + readApplicationLauncherApplicationLauncherListCommandParams); + readApplicationLauncherInteractionInfo.put( + "readApplicationLauncherListAttribute", + readApplicationLauncherApplicationLauncherListAttributeInteractionInfo); + Map readApplicationLauncherAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ApplicationLauncherCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedApplicationLauncherClusterAttributeListAttributeCallback(), + readApplicationLauncherAttributeListCommandParams); + readApplicationLauncherInteractionInfo.put( + "readAttributeListAttribute", readApplicationLauncherAttributeListAttributeInteractionInfo); + Map readApplicationLauncherClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readApplicationLauncherClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ApplicationLauncherCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readApplicationLauncherClusterRevisionCommandParams); + readApplicationLauncherInteractionInfo.put( + "readClusterRevisionAttribute", + readApplicationLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("applicationLauncher", readApplicationLauncherInteractionInfo); + Map readAudioOutputInteractionInfo = new LinkedHashMap<>(); + Map readAudioOutputAudioOutputListCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputAudioOutputListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readAudioOutputListAttribute( + (ChipClusters.AudioOutputCluster.AudioOutputListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedAudioOutputClusterAudioOutputListAttributeCallback(), + readAudioOutputAudioOutputListCommandParams); + readAudioOutputInteractionInfo.put( + "readAudioOutputListAttribute", readAudioOutputAudioOutputListAttributeInteractionInfo); + Map readAudioOutputCurrentAudioOutputCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputCurrentAudioOutputAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readCurrentAudioOutputAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputCurrentAudioOutputCommandParams); + readAudioOutputInteractionInfo.put( + "readCurrentAudioOutputAttribute", + readAudioOutputCurrentAudioOutputAttributeInteractionInfo); + Map readAudioOutputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.AudioOutputCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedAudioOutputClusterAttributeListAttributeCallback(), + readAudioOutputAttributeListCommandParams); + readAudioOutputInteractionInfo.put( + "readAttributeListAttribute", readAudioOutputAttributeListAttributeInteractionInfo); + Map readAudioOutputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readAudioOutputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.AudioOutputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readAudioOutputClusterRevisionCommandParams); + readAudioOutputInteractionInfo.put( + "readClusterRevisionAttribute", readAudioOutputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("audioOutput", readAudioOutputInteractionInfo); + Map readBarrierControlInteractionInfo = new LinkedHashMap<>(); + Map readBarrierControlBarrierMovingStateCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierMovingStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierMovingStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierMovingStateCommandParams); + readBarrierControlInteractionInfo.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); + readBarrierControlInteractionInfo.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); + readBarrierControlInteractionInfo.put( + "readBarrierCapabilitiesAttribute", + readBarrierControlBarrierCapabilitiesAttributeInteractionInfo); + Map readBarrierControlBarrierPositionCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlBarrierPositionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readBarrierPositionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlBarrierPositionCommandParams); + readBarrierControlInteractionInfo.put( + "readBarrierPositionAttribute", readBarrierControlBarrierPositionAttributeInteractionInfo); + Map readBarrierControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BarrierControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBarrierControlClusterAttributeListAttributeCallback(), + readBarrierControlAttributeListCommandParams); + readBarrierControlInteractionInfo.put( + "readAttributeListAttribute", readBarrierControlAttributeListAttributeInteractionInfo); + Map readBarrierControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBarrierControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BarrierControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBarrierControlClusterRevisionCommandParams); + readBarrierControlInteractionInfo.put( + "readClusterRevisionAttribute", readBarrierControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("barrierControl", readBarrierControlInteractionInfo); + Map readBasicInteractionInfo = new LinkedHashMap<>(); + Map readBasicInteractionModelVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicInteractionModelVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readInteractionModelVersionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicInteractionModelVersionCommandParams); + readBasicInteractionInfo.put( + "readInteractionModelVersionAttribute", + readBasicInteractionModelVersionAttributeInteractionInfo); + Map readBasicVendorNameCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicVendorNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readVendorNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicVendorNameCommandParams - ); - readBasicInteractionInfo.put("readVendorNameAttribute", readBasicVendorNameAttributeInteractionInfo); - Map readBasicVendorIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicVendorIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readVendorIDAttribute( - ( ChipClusters.BasicCluster.VendorIDAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicVendorIDCommandParams - ); - readBasicInteractionInfo.put("readVendorIDAttribute", readBasicVendorIDAttributeInteractionInfo); - Map readBasicProductNameCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicVendorNameCommandParams); + readBasicInteractionInfo.put( + "readVendorNameAttribute", readBasicVendorNameAttributeInteractionInfo); + Map readBasicVendorIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicVendorIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readVendorIDAttribute( + (ChipClusters.BasicCluster.VendorIDAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicVendorIDCommandParams); + readBasicInteractionInfo.put( + "readVendorIDAttribute", readBasicVendorIDAttributeInteractionInfo); + Map readBasicProductNameCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductNameCommandParams - ); - readBasicInteractionInfo.put("readProductNameAttribute", readBasicProductNameAttributeInteractionInfo); - Map readBasicProductIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductIDAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicProductIDCommandParams - ); - readBasicInteractionInfo.put("readProductIDAttribute", readBasicProductIDAttributeInteractionInfo); - Map readBasicNodeLabelCommandParams = new LinkedHashMap(); - InteractionInfo readBasicNodeLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readNodeLabelAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicProductNameCommandParams); + readBasicInteractionInfo.put( + "readProductNameAttribute", readBasicProductNameAttributeInteractionInfo); + Map readBasicProductIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductIDAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicProductIDCommandParams); + readBasicInteractionInfo.put( + "readProductIDAttribute", readBasicProductIDAttributeInteractionInfo); + Map readBasicNodeLabelCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicNodeLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readNodeLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicNodeLabelCommandParams - ); - readBasicInteractionInfo.put("readNodeLabelAttribute", readBasicNodeLabelAttributeInteractionInfo); - Map readBasicLocationCommandParams = new LinkedHashMap(); - InteractionInfo readBasicLocationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readLocationAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicNodeLabelCommandParams); + readBasicInteractionInfo.put( + "readNodeLabelAttribute", readBasicNodeLabelAttributeInteractionInfo); + Map readBasicLocationCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicLocationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readLocationAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicLocationCommandParams - ); - readBasicInteractionInfo.put("readLocationAttribute", readBasicLocationAttributeInteractionInfo); - Map readBasicHardwareVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicHardwareVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readHardwareVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicHardwareVersionCommandParams - ); - readBasicInteractionInfo.put("readHardwareVersionAttribute", readBasicHardwareVersionAttributeInteractionInfo); - Map readBasicHardwareVersionStringCommandParams = new LinkedHashMap(); - InteractionInfo readBasicHardwareVersionStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readHardwareVersionStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicLocationCommandParams); + readBasicInteractionInfo.put( + "readLocationAttribute", readBasicLocationAttributeInteractionInfo); + Map readBasicHardwareVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicHardwareVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readHardwareVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicHardwareVersionCommandParams); + readBasicInteractionInfo.put( + "readHardwareVersionAttribute", readBasicHardwareVersionAttributeInteractionInfo); + Map readBasicHardwareVersionStringCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicHardwareVersionStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readHardwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicHardwareVersionStringCommandParams - ); - readBasicInteractionInfo.put("readHardwareVersionStringAttribute", readBasicHardwareVersionStringAttributeInteractionInfo); - Map readBasicSoftwareVersionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicSoftwareVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readSoftwareVersionAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readBasicHardwareVersionStringCommandParams); + readBasicInteractionInfo.put( + "readHardwareVersionStringAttribute", + readBasicHardwareVersionStringAttributeInteractionInfo); + Map readBasicSoftwareVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicSoftwareVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readSoftwareVersionAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readBasicSoftwareVersionCommandParams - ); - readBasicInteractionInfo.put("readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeInteractionInfo); - Map readBasicSoftwareVersionStringCommandParams = new LinkedHashMap(); - InteractionInfo readBasicSoftwareVersionStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readSoftwareVersionStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicSoftwareVersionCommandParams); + readBasicInteractionInfo.put( + "readSoftwareVersionAttribute", readBasicSoftwareVersionAttributeInteractionInfo); + Map readBasicSoftwareVersionStringCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicSoftwareVersionStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readSoftwareVersionStringAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicSoftwareVersionStringCommandParams - ); - readBasicInteractionInfo.put("readSoftwareVersionStringAttribute", readBasicSoftwareVersionStringAttributeInteractionInfo); - Map readBasicManufacturingDateCommandParams = new LinkedHashMap(); - InteractionInfo readBasicManufacturingDateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readManufacturingDateAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicSoftwareVersionStringCommandParams); + readBasicInteractionInfo.put( + "readSoftwareVersionStringAttribute", + readBasicSoftwareVersionStringAttributeInteractionInfo); + Map readBasicManufacturingDateCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicManufacturingDateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readManufacturingDateAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicManufacturingDateCommandParams - ); - readBasicInteractionInfo.put("readManufacturingDateAttribute", readBasicManufacturingDateAttributeInteractionInfo); - Map readBasicPartNumberCommandParams = new LinkedHashMap(); - InteractionInfo readBasicPartNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readPartNumberAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicManufacturingDateCommandParams); + readBasicInteractionInfo.put( + "readManufacturingDateAttribute", readBasicManufacturingDateAttributeInteractionInfo); + Map readBasicPartNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicPartNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readPartNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicPartNumberCommandParams - ); - readBasicInteractionInfo.put("readPartNumberAttribute", readBasicPartNumberAttributeInteractionInfo); - Map readBasicProductURLCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductURLAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductURLAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicPartNumberCommandParams); + readBasicInteractionInfo.put( + "readPartNumberAttribute", readBasicPartNumberAttributeInteractionInfo); + Map readBasicProductURLCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductURLAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductURLAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductURLCommandParams - ); - readBasicInteractionInfo.put("readProductURLAttribute", readBasicProductURLAttributeInteractionInfo); - Map readBasicProductLabelCommandParams = new LinkedHashMap(); - InteractionInfo readBasicProductLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readProductLabelAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicProductURLCommandParams); + readBasicInteractionInfo.put( + "readProductURLAttribute", readBasicProductURLAttributeInteractionInfo); + Map readBasicProductLabelCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicProductLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readProductLabelAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicProductLabelCommandParams - ); - readBasicInteractionInfo.put("readProductLabelAttribute", readBasicProductLabelAttributeInteractionInfo); - Map readBasicSerialNumberCommandParams = new LinkedHashMap(); - InteractionInfo readBasicSerialNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readSerialNumberAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicProductLabelCommandParams); + readBasicInteractionInfo.put( + "readProductLabelAttribute", readBasicProductLabelAttributeInteractionInfo); + Map readBasicSerialNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicSerialNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readSerialNumberAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicSerialNumberCommandParams - ); - readBasicInteractionInfo.put("readSerialNumberAttribute", readBasicSerialNumberAttributeInteractionInfo); - Map readBasicLocalConfigDisabledCommandParams = new LinkedHashMap(); - InteractionInfo readBasicLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readLocalConfigDisabledAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBasicSerialNumberCommandParams); + readBasicInteractionInfo.put( + "readSerialNumberAttribute", readBasicSerialNumberAttributeInteractionInfo); + Map readBasicLocalConfigDisabledCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicLocalConfigDisabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readLocalConfigDisabledAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicLocalConfigDisabledCommandParams - ); - readBasicInteractionInfo.put("readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeInteractionInfo); - Map readBasicReachableCommandParams = new LinkedHashMap(); - InteractionInfo readBasicReachableAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readReachableAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBasicLocalConfigDisabledCommandParams); + readBasicInteractionInfo.put( + "readLocalConfigDisabledAttribute", readBasicLocalConfigDisabledAttributeInteractionInfo); + Map readBasicReachableCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicReachableAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readReachableAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBasicReachableCommandParams - ); - readBasicInteractionInfo.put("readReachableAttribute", readBasicReachableAttributeInteractionInfo); - Map readBasicUniqueIDCommandParams = new LinkedHashMap(); - InteractionInfo readBasicUniqueIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readUniqueIDAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBasicReachableCommandParams); + readBasicInteractionInfo.put( + "readReachableAttribute", readBasicReachableAttributeInteractionInfo); + Map readBasicUniqueIDCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicUniqueIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readUniqueIDAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBasicUniqueIDCommandParams - ); - readBasicInteractionInfo.put("readUniqueIDAttribute", readBasicUniqueIDAttributeInteractionInfo); - Map readBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BasicCluster.AttributeListAttributeCallback - ) callback - ); - }, + readBasicUniqueIDCommandParams); + readBasicInteractionInfo.put( + "readUniqueIDAttribute", readBasicUniqueIDAttributeInteractionInfo); + Map readBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BasicCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBasicClusterAttributeListAttributeCallback(), - readBasicAttributeListCommandParams - ); - readBasicInteractionInfo.put("readAttributeListAttribute", readBasicAttributeListAttributeInteractionInfo); - Map readBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBasicClusterRevisionCommandParams - ); - readBasicInteractionInfo.put("readClusterRevisionAttribute", readBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("basic", readBasicInteractionInfo); - Map readBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map readBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readOutOfServiceAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBasicAttributeListCommandParams); + readBasicInteractionInfo.put( + "readAttributeListAttribute", readBasicAttributeListAttributeInteractionInfo); + Map readBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBasicClusterRevisionCommandParams); + readBasicInteractionInfo.put( + "readClusterRevisionAttribute", readBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("basic", readBasicInteractionInfo); + Map readBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); + Map readBinaryInputBasicOutOfServiceCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicOutOfServiceAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readOutOfServiceAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicOutOfServiceCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); - Map readBinaryInputBasicPresentValueCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readPresentValueAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBinaryInputBasicOutOfServiceCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readOutOfServiceAttribute", readBinaryInputBasicOutOfServiceAttributeInteractionInfo); + Map readBinaryInputBasicPresentValueCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicPresentValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readPresentValueAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBinaryInputBasicPresentValueCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); - Map readBinaryInputBasicStatusFlagsCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readStatusFlagsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicStatusFlagsCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); - Map readBinaryInputBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), - readBinaryInputBasicAttributeListCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); - Map readBinaryInputBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BinaryInputBasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBinaryInputBasicClusterRevisionCommandParams - ); - readBinaryInputBasicInteractionInfo.put("readClusterRevisionAttribute", readBinaryInputBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("binaryInputBasic", readBinaryInputBasicInteractionInfo); - Map readBindingInteractionInfo = new LinkedHashMap<>(); - Map readBindingAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBindingAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BindingCluster.AttributeListAttributeCallback - ) callback - ); - }, + readBinaryInputBasicPresentValueCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readPresentValueAttribute", readBinaryInputBasicPresentValueAttributeInteractionInfo); + Map readBinaryInputBasicStatusFlagsCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicStatusFlagsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readStatusFlagsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicStatusFlagsCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readStatusFlagsAttribute", readBinaryInputBasicStatusFlagsAttributeInteractionInfo); + Map readBinaryInputBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BinaryInputBasicCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBinaryInputBasicClusterAttributeListAttributeCallback(), + readBinaryInputBasicAttributeListCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readAttributeListAttribute", readBinaryInputBasicAttributeListAttributeInteractionInfo); + Map readBinaryInputBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBinaryInputBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BinaryInputBasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBinaryInputBasicClusterRevisionCommandParams); + readBinaryInputBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readBinaryInputBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binaryInputBasic", readBinaryInputBasicInteractionInfo); + Map readBindingInteractionInfo = new LinkedHashMap<>(); + Map readBindingAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BindingCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBindingClusterAttributeListAttributeCallback(), - readBindingAttributeListCommandParams - ); - readBindingInteractionInfo.put("readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); - Map readBindingClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BindingCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBindingClusterRevisionCommandParams - ); - readBindingInteractionInfo.put("readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("binding", readBindingInteractionInfo); - Map readBooleanStateInteractionInfo = new LinkedHashMap<>(); - Map readBooleanStateStateValueCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readStateValueAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readBindingAttributeListCommandParams); + readBindingInteractionInfo.put( + "readAttributeListAttribute", readBindingAttributeListAttributeInteractionInfo); + Map readBindingClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBindingClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BindingCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBindingClusterRevisionCommandParams); + readBindingInteractionInfo.put( + "readClusterRevisionAttribute", readBindingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("binding", readBindingInteractionInfo); + Map readBooleanStateInteractionInfo = new LinkedHashMap<>(); + Map readBooleanStateStateValueCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateStateValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readStateValueAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readBooleanStateStateValueCommandParams - ); - readBooleanStateInteractionInfo.put("readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); - Map readBooleanStateAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BooleanStateCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), - readBooleanStateAttributeListCommandParams - ); - readBooleanStateInteractionInfo.put("readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); - Map readBooleanStateClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BooleanStateCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBooleanStateClusterRevisionCommandParams - ); - readBooleanStateInteractionInfo.put("readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("booleanState", readBooleanStateInteractionInfo); - Map readBridgedActionsInteractionInfo = new LinkedHashMap<>(); - Map readBridgedActionsActionListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsActionListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readActionListAttribute( - ( ChipClusters.BridgedActionsCluster.ActionListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterActionListAttributeCallback(), - readBridgedActionsActionListCommandParams - ); - readBridgedActionsInteractionInfo.put("readActionListAttribute", readBridgedActionsActionListAttributeInteractionInfo); - Map readBridgedActionsEndpointListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsEndpointListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readEndpointListAttribute( - ( ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterEndpointListAttributeCallback(), - readBridgedActionsEndpointListCommandParams - ); - readBridgedActionsInteractionInfo.put("readEndpointListAttribute", readBridgedActionsEndpointListAttributeInteractionInfo); - Map readBridgedActionsSetupUrlCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsSetupUrlAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readSetupUrlAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readBooleanStateStateValueCommandParams); + readBooleanStateInteractionInfo.put( + "readStateValueAttribute", readBooleanStateStateValueAttributeInteractionInfo); + Map readBooleanStateAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BooleanStateCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedBooleanStateClusterAttributeListAttributeCallback(), + readBooleanStateAttributeListCommandParams); + readBooleanStateInteractionInfo.put( + "readAttributeListAttribute", readBooleanStateAttributeListAttributeInteractionInfo); + Map readBooleanStateClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBooleanStateClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BooleanStateCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBooleanStateClusterRevisionCommandParams); + readBooleanStateInteractionInfo.put( + "readClusterRevisionAttribute", readBooleanStateClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("booleanState", readBooleanStateInteractionInfo); + Map readBridgedActionsInteractionInfo = new LinkedHashMap<>(); + Map readBridgedActionsActionListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsActionListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readActionListAttribute( + (ChipClusters.BridgedActionsCluster.ActionListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedBridgedActionsClusterActionListAttributeCallback(), + readBridgedActionsActionListCommandParams); + readBridgedActionsInteractionInfo.put( + "readActionListAttribute", readBridgedActionsActionListAttributeInteractionInfo); + Map readBridgedActionsEndpointListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsEndpointListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readEndpointListAttribute( + (ChipClusters.BridgedActionsCluster.EndpointListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedActionsClusterEndpointListAttributeCallback(), + readBridgedActionsEndpointListCommandParams); + readBridgedActionsInteractionInfo.put( + "readEndpointListAttribute", readBridgedActionsEndpointListAttributeInteractionInfo); + Map readBridgedActionsSetupUrlCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsSetupUrlAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readSetupUrlAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readBridgedActionsSetupUrlCommandParams - ); - readBridgedActionsInteractionInfo.put("readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeInteractionInfo); - Map readBridgedActionsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BridgedActionsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedActionsClusterAttributeListAttributeCallback(), - readBridgedActionsAttributeListCommandParams - ); - readBridgedActionsInteractionInfo.put("readAttributeListAttribute", readBridgedActionsAttributeListAttributeInteractionInfo); - Map readBridgedActionsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedActionsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedActionsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedActionsClusterRevisionCommandParams - ); - readBridgedActionsInteractionInfo.put("readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("bridgedActions", readBridgedActionsInteractionInfo); - Map readBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); - Map readBridgedDeviceBasicAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicCluster) cluster).readAttributeListAttribute( - ( ChipClusters.BridgedDeviceBasicCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback(), - readBridgedDeviceBasicAttributeListCommandParams - ); - readBridgedDeviceBasicInteractionInfo.put("readAttributeListAttribute", readBridgedDeviceBasicAttributeListAttributeInteractionInfo); - Map readBridgedDeviceBasicClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BridgedDeviceBasicCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readBridgedDeviceBasicClusterRevisionCommandParams - ); - readBridgedDeviceBasicInteractionInfo.put("readClusterRevisionAttribute", readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("bridgedDeviceBasic", readBridgedDeviceBasicInteractionInfo); - Map readChannelInteractionInfo = new LinkedHashMap<>(); - Map readChannelChannelListCommandParams = new LinkedHashMap(); - InteractionInfo readChannelChannelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readChannelListAttribute( - ( ChipClusters.ChannelCluster.ChannelListAttributeCallback - ) callback - ); - }, + readBridgedActionsSetupUrlCommandParams); + readBridgedActionsInteractionInfo.put( + "readSetupUrlAttribute", readBridgedActionsSetupUrlAttributeInteractionInfo); + Map readBridgedActionsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BridgedActionsCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedActionsClusterAttributeListAttributeCallback(), + readBridgedActionsAttributeListCommandParams); + readBridgedActionsInteractionInfo.put( + "readAttributeListAttribute", readBridgedActionsAttributeListAttributeInteractionInfo); + Map readBridgedActionsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedActionsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedActionsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedActionsClusterRevisionCommandParams); + readBridgedActionsInteractionInfo.put( + "readClusterRevisionAttribute", readBridgedActionsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedActions", readBridgedActionsInteractionInfo); + Map readBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); + Map readBridgedDeviceBasicAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.BridgedDeviceBasicCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedBridgedDeviceBasicClusterAttributeListAttributeCallback(), + readBridgedDeviceBasicAttributeListCommandParams); + readBridgedDeviceBasicInteractionInfo.put( + "readAttributeListAttribute", readBridgedDeviceBasicAttributeListAttributeInteractionInfo); + Map readBridgedDeviceBasicClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BridgedDeviceBasicCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readBridgedDeviceBasicClusterRevisionCommandParams); + readBridgedDeviceBasicInteractionInfo.put( + "readClusterRevisionAttribute", + readBridgedDeviceBasicClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("bridgedDeviceBasic", readBridgedDeviceBasicInteractionInfo); + Map readChannelInteractionInfo = 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 - ); - readChannelInteractionInfo.put("readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); - Map readChannelAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readChannelAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ChannelCluster.AttributeListAttributeCallback - ) callback - ); - }, + readChannelChannelListCommandParams); + readChannelInteractionInfo.put( + "readChannelListAttribute", readChannelChannelListAttributeInteractionInfo); + Map readChannelAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ChannelCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedChannelClusterAttributeListAttributeCallback(), - readChannelAttributeListCommandParams - ); - readChannelInteractionInfo.put("readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); - Map readChannelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ChannelCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readChannelClusterRevisionCommandParams - ); - readChannelInteractionInfo.put("readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("channel", readChannelInteractionInfo); - Map readColorControlInteractionInfo = new LinkedHashMap<>(); - Map readColorControlCurrentHueCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCurrentHueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCurrentHueCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readDriftCompensationAttribute", readColorControlDriftCompensationAttributeInteractionInfo); - Map readColorControlCompensationTextCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCompensationTextAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCompensationTextAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readChannelAttributeListCommandParams); + readChannelInteractionInfo.put( + "readAttributeListAttribute", readChannelAttributeListAttributeInteractionInfo); + Map readChannelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readChannelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ChannelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readChannelClusterRevisionCommandParams); + readChannelInteractionInfo.put( + "readClusterRevisionAttribute", readChannelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("channel", readChannelInteractionInfo); + Map readColorControlInteractionInfo = new LinkedHashMap<>(); + Map readColorControlCurrentHueCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCurrentHueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCurrentHueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCurrentHueCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); - Map readColorControlColorTemperatureCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTemperatureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTemperatureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTemperatureCommandParams - ); - readColorControlInteractionInfo.put("readColorTemperatureAttribute", readColorControlColorTemperatureAttributeInteractionInfo); - Map readColorControlColorModeCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorModeCommandParams - ); - readColorControlInteractionInfo.put("readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); - Map readColorControlColorControlOptionsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorControlOptionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorControlOptionsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorControlOptionsCommandParams - ); - readColorControlInteractionInfo.put("readColorControlOptionsAttribute", readColorControlColorControlOptionsAttributeInteractionInfo); - Map readColorControlNumberOfPrimariesCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readNumberOfPrimariesAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlNumberOfPrimariesCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); - Map readColorControlPrimary1IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary1IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary1IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); - Map readColorControlPrimary2IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary2IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary2IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); - Map readColorControlPrimary3IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary3IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary3IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); - Map readColorControlPrimary4IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary4IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary4IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); - Map readColorControlPrimary5IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary5IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary5IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); - Map readColorControlPrimary6IntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readPrimary6IntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlPrimary6IntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); - Map readColorControlColorPointRIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointRIntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointRIntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); - Map readColorControlColorPointGIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointGIntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointGIntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); - Map readColorControlColorPointBIntensityCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorPointBIntensityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorPointBIntensityCommandParams - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.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 - ); - readColorControlInteractionInfo.put("readColorCapabilitiesAttribute", readColorControlColorCapabilitiesAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMinCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMinAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMinAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMinCommandParams - ); - readColorControlInteractionInfo.put("readColorTempPhysicalMinAttribute", readColorControlColorTempPhysicalMinAttributeInteractionInfo); - Map readColorControlColorTempPhysicalMaxCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlColorTempPhysicalMaxAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readColorTempPhysicalMaxAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlColorTempPhysicalMaxCommandParams - ); - readColorControlInteractionInfo.put("readColorTempPhysicalMaxAttribute", readColorControlColorTempPhysicalMaxAttributeInteractionInfo); - Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readCoupleColorTempToLevelMinMiredsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlCoupleColorTempToLevelMinMiredsCommandParams - ); - readColorControlInteractionInfo.put("readCoupleColorTempToLevelMinMiredsAttribute", readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); - Map readColorControlStartUpColorTemperatureMiredsCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readStartUpColorTemperatureMiredsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlStartUpColorTemperatureMiredsCommandParams - ); - readColorControlInteractionInfo.put("readStartUpColorTemperatureMiredsAttribute", readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); - Map readColorControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ColorControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), - readColorControlAttributeListCommandParams - ); - readColorControlInteractionInfo.put("readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); - Map readColorControlClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readColorControlClusterRevisionCommandParams - ); - readColorControlInteractionInfo.put("readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("colorControl", readColorControlInteractionInfo); - Map readContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map readContentLauncherAcceptHeaderListCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherAcceptHeaderListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readAcceptHeaderListAttribute( - ( ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback(), - readContentLauncherAcceptHeaderListCommandParams - ); - readContentLauncherInteractionInfo.put("readAcceptHeaderListAttribute", readContentLauncherAcceptHeaderListAttributeInteractionInfo); - Map readContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readSupportedStreamingProtocolsAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readColorControlCompensationTextCommandParams); + readColorControlInteractionInfo.put( + "readCompensationTextAttribute", readColorControlCompensationTextAttributeInteractionInfo); + Map readColorControlColorTemperatureCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTemperatureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTemperatureCommandParams); + readColorControlInteractionInfo.put( + "readColorTemperatureAttribute", readColorControlColorTemperatureAttributeInteractionInfo); + Map readColorControlColorModeCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorModeCommandParams); + readColorControlInteractionInfo.put( + "readColorModeAttribute", readColorControlColorModeAttributeInteractionInfo); + Map readColorControlColorControlOptionsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorControlOptionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorControlOptionsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorControlOptionsCommandParams); + readColorControlInteractionInfo.put( + "readColorControlOptionsAttribute", + readColorControlColorControlOptionsAttributeInteractionInfo); + Map readColorControlNumberOfPrimariesCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlNumberOfPrimariesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readNumberOfPrimariesAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlNumberOfPrimariesCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary1YAttribute", readColorControlPrimary1YAttributeInteractionInfo); + Map readColorControlPrimary1IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary1IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary1IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary1IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary2YAttribute", readColorControlPrimary2YAttributeInteractionInfo); + Map readColorControlPrimary2IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary2IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary2IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary2IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary3YAttribute", readColorControlPrimary3YAttributeInteractionInfo); + Map readColorControlPrimary3IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary3IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary3IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary3IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary4YAttribute", readColorControlPrimary4YAttributeInteractionInfo); + Map readColorControlPrimary4IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary4IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary4IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary4IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary5YAttribute", readColorControlPrimary5YAttributeInteractionInfo); + Map readColorControlPrimary5IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary5IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary5IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary5IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readPrimary6YAttribute", readColorControlPrimary6YAttributeInteractionInfo); + Map readColorControlPrimary6IntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlPrimary6IntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readPrimary6IntensityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlPrimary6IntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorPointRYAttribute", readColorControlColorPointRYAttributeInteractionInfo); + Map readColorControlColorPointRIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointRIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointRIntensityAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointRIntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorPointGYAttribute", readColorControlColorPointGYAttributeInteractionInfo); + Map readColorControlColorPointGIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointGIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointGIntensityAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointGIntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorPointBYAttribute", readColorControlColorPointBYAttributeInteractionInfo); + Map readColorControlColorPointBIntensityCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorPointBIntensityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorPointBIntensityAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorPointBIntensityCommandParams); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.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); + readColorControlInteractionInfo.put( + "readColorCapabilitiesAttribute", + readColorControlColorCapabilitiesAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMinCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMinAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTempPhysicalMinAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMinCommandParams); + readColorControlInteractionInfo.put( + "readColorTempPhysicalMinAttribute", + readColorControlColorTempPhysicalMinAttributeInteractionInfo); + Map readColorControlColorTempPhysicalMaxCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlColorTempPhysicalMaxAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readColorTempPhysicalMaxAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlColorTempPhysicalMaxCommandParams); + readColorControlInteractionInfo.put( + "readColorTempPhysicalMaxAttribute", + readColorControlColorTempPhysicalMaxAttributeInteractionInfo); + Map readColorControlCoupleColorTempToLevelMinMiredsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readCoupleColorTempToLevelMinMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlCoupleColorTempToLevelMinMiredsCommandParams); + readColorControlInteractionInfo.put( + "readCoupleColorTempToLevelMinMiredsAttribute", + readColorControlCoupleColorTempToLevelMinMiredsAttributeInteractionInfo); + Map readColorControlStartUpColorTemperatureMiredsCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readStartUpColorTemperatureMiredsAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlStartUpColorTemperatureMiredsCommandParams); + readColorControlInteractionInfo.put( + "readStartUpColorTemperatureMiredsAttribute", + readColorControlStartUpColorTemperatureMiredsAttributeInteractionInfo); + Map readColorControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ColorControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedColorControlClusterAttributeListAttributeCallback(), + readColorControlAttributeListCommandParams); + readColorControlInteractionInfo.put( + "readAttributeListAttribute", readColorControlAttributeListAttributeInteractionInfo); + Map readColorControlClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readColorControlClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readColorControlClusterRevisionCommandParams); + readColorControlInteractionInfo.put( + "readClusterRevisionAttribute", readColorControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("colorControl", readColorControlInteractionInfo); + Map readContentLauncherInteractionInfo = new LinkedHashMap<>(); + Map readContentLauncherAcceptHeaderListCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherAcceptHeaderListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readAcceptHeaderListAttribute( + (ChipClusters.ContentLauncherCluster.AcceptHeaderListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedContentLauncherClusterAcceptHeaderListAttributeCallback(), + readContentLauncherAcceptHeaderListCommandParams); + readContentLauncherInteractionInfo.put( + "readAcceptHeaderListAttribute", + readContentLauncherAcceptHeaderListAttributeInteractionInfo); + Map readContentLauncherSupportedStreamingProtocolsCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readSupportedStreamingProtocolsAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readContentLauncherSupportedStreamingProtocolsCommandParams - ); - readContentLauncherInteractionInfo.put("readSupportedStreamingProtocolsAttribute", readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); - Map readContentLauncherAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedContentLauncherClusterAttributeListAttributeCallback(), - readContentLauncherAttributeListCommandParams - ); - readContentLauncherInteractionInfo.put("readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); - Map readContentLauncherClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ContentLauncherCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readContentLauncherClusterRevisionCommandParams - ); - readContentLauncherInteractionInfo.put("readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("contentLauncher", readContentLauncherInteractionInfo); - Map readDescriptorInteractionInfo = new LinkedHashMap<>(); - Map readDescriptorDeviceListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorDeviceListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readDeviceListAttribute( - ( ChipClusters.DescriptorCluster.DeviceListAttributeCallback - ) callback - ); - }, + readContentLauncherSupportedStreamingProtocolsCommandParams); + readContentLauncherInteractionInfo.put( + "readSupportedStreamingProtocolsAttribute", + readContentLauncherSupportedStreamingProtocolsAttributeInteractionInfo); + Map readContentLauncherAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ContentLauncherCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedContentLauncherClusterAttributeListAttributeCallback(), + readContentLauncherAttributeListCommandParams); + readContentLauncherInteractionInfo.put( + "readAttributeListAttribute", readContentLauncherAttributeListAttributeInteractionInfo); + Map readContentLauncherClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readContentLauncherClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ContentLauncherCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readContentLauncherClusterRevisionCommandParams); + readContentLauncherInteractionInfo.put( + "readClusterRevisionAttribute", readContentLauncherClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("contentLauncher", readContentLauncherInteractionInfo); + Map readDescriptorInteractionInfo = new LinkedHashMap<>(); + Map readDescriptorDeviceListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorDeviceListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readDeviceListAttribute( + (ChipClusters.DescriptorCluster.DeviceListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterDeviceListAttributeCallback(), - readDescriptorDeviceListCommandParams - ); - readDescriptorInteractionInfo.put("readDeviceListAttribute", readDescriptorDeviceListAttributeInteractionInfo); - Map readDescriptorServerListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorServerListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readServerListAttribute( - ( ChipClusters.DescriptorCluster.ServerListAttributeCallback - ) callback - ); - }, + readDescriptorDeviceListCommandParams); + readDescriptorInteractionInfo.put( + "readDeviceListAttribute", readDescriptorDeviceListAttributeInteractionInfo); + Map readDescriptorServerListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorServerListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readServerListAttribute( + (ChipClusters.DescriptorCluster.ServerListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterServerListAttributeCallback(), - readDescriptorServerListCommandParams - ); - readDescriptorInteractionInfo.put("readServerListAttribute", readDescriptorServerListAttributeInteractionInfo); - Map readDescriptorClientListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorClientListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readClientListAttribute( - ( ChipClusters.DescriptorCluster.ClientListAttributeCallback - ) callback - ); - }, + readDescriptorServerListCommandParams); + readDescriptorInteractionInfo.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 - ); - readDescriptorInteractionInfo.put("readClientListAttribute", readDescriptorClientListAttributeInteractionInfo); - Map readDescriptorPartsListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorPartsListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readPartsListAttribute( - ( ChipClusters.DescriptorCluster.PartsListAttributeCallback - ) callback - ); - }, + readDescriptorClientListCommandParams); + readDescriptorInteractionInfo.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 - ); - readDescriptorInteractionInfo.put("readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); - Map readDescriptorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readAttributeListAttribute( - ( ChipClusters.DescriptorCluster.AttributeListAttributeCallback - ) callback - ); - }, + readDescriptorPartsListCommandParams); + readDescriptorInteractionInfo.put( + "readPartsListAttribute", readDescriptorPartsListAttributeInteractionInfo); + Map readDescriptorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DescriptorCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDescriptorClusterAttributeListAttributeCallback(), - readDescriptorAttributeListCommandParams - ); - readDescriptorInteractionInfo.put("readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); - Map readDescriptorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DescriptorCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDescriptorClusterRevisionCommandParams - ); - readDescriptorInteractionInfo.put("readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("descriptor", readDescriptorInteractionInfo); - Map readDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); - Map readDiagnosticLogsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DiagnosticLogsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), - readDiagnosticLogsAttributeListCommandParams - ); - readDiagnosticLogsInteractionInfo.put("readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); - readAttributeMap.put("diagnosticLogs", readDiagnosticLogsInteractionInfo); - Map readDoorLockInteractionInfo = new LinkedHashMap<>(); - Map readDoorLockLockStateCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockLockStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readLockStateAttribute( - ( ChipClusters.DoorLockCluster.LockStateAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockLockStateCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readLockTypeAttribute", readDoorLockLockTypeAttributeInteractionInfo); - Map readDoorLockActuatorEnabledCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockActuatorEnabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readActuatorEnabledAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readDescriptorAttributeListCommandParams); + readDescriptorInteractionInfo.put( + "readAttributeListAttribute", readDescriptorAttributeListAttributeInteractionInfo); + Map readDescriptorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readDescriptorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DescriptorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDescriptorClusterRevisionCommandParams); + readDescriptorInteractionInfo.put( + "readClusterRevisionAttribute", readDescriptorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("descriptor", readDescriptorInteractionInfo); + Map readDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); + Map readDiagnosticLogsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDiagnosticLogsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DiagnosticLogsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DiagnosticLogsCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedDiagnosticLogsClusterAttributeListAttributeCallback(), + readDiagnosticLogsAttributeListCommandParams); + readDiagnosticLogsInteractionInfo.put( + "readAttributeListAttribute", readDiagnosticLogsAttributeListAttributeInteractionInfo); + readAttributeMap.put("diagnosticLogs", readDiagnosticLogsInteractionInfo); + Map readDoorLockInteractionInfo = new LinkedHashMap<>(); + Map readDoorLockLockStateCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockLockStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readLockStateAttribute( + (ChipClusters.DoorLockCluster.LockStateAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockLockStateCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); - Map readDoorLockDoorStateCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readDoorStateAttribute( - ( ChipClusters.DoorLockCluster.DoorStateAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockDoorStateCommandParams - ); - readDoorLockInteractionInfo.put("readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); - Map readDoorLockNumberOfTotalUsersSupportedCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readNumberOfTotalUsersSupportedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockNumberOfTotalUsersSupportedCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readNumberOfYearDaySchedulesSupportedPerUserAttribute", readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); - Map readDoorLockMaxPINCodeLengthCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readMaxPINCodeLengthAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockMaxPINCodeLengthCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); - Map readDoorLockLanguageCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockLanguageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readLanguageAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readDoorLockActuatorEnabledCommandParams); + readDoorLockInteractionInfo.put( + "readActuatorEnabledAttribute", readDoorLockActuatorEnabledAttributeInteractionInfo); + Map readDoorLockDoorStateCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockDoorStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readDoorStateAttribute( + (ChipClusters.DoorLockCluster.DoorStateAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockDoorStateCommandParams); + readDoorLockInteractionInfo.put( + "readDoorStateAttribute", readDoorLockDoorStateAttributeInteractionInfo); + Map readDoorLockNumberOfTotalUsersSupportedCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockNumberOfTotalUsersSupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readNumberOfTotalUsersSupportedAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockNumberOfTotalUsersSupportedCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.put( + "readNumberOfYearDaySchedulesSupportedPerUserAttribute", + readDoorLockNumberOfYearDaySchedulesSupportedPerUserAttributeInteractionInfo); + Map readDoorLockMaxPINCodeLengthCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockMaxPINCodeLengthAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readMaxPINCodeLengthAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockMaxPINCodeLengthCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.put( + "readMinRFIDCodeLengthAttribute", readDoorLockMinRFIDCodeLengthAttributeInteractionInfo); + Map readDoorLockLanguageCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockLanguageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readLanguageAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readDoorLockLanguageCommandParams - ); - readDoorLockInteractionInfo.put("readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); - Map readDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readAutoRelockTimeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readDoorLockLanguageCommandParams); + readDoorLockInteractionInfo.put( + "readLanguageAttribute", readDoorLockLanguageAttributeInteractionInfo); + Map readDoorLockAutoRelockTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockAutoRelockTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readAutoRelockTimeAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readDoorLockAutoRelockTimeCommandParams - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.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 - ); - readDoorLockInteractionInfo.put("readSupportedOperatingModesAttribute", readDoorLockSupportedOperatingModesAttributeInteractionInfo); - Map readDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readEnableOneTouchLockingAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readDoorLockAutoRelockTimeCommandParams); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.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); + readDoorLockInteractionInfo.put( + "readSupportedOperatingModesAttribute", + readDoorLockSupportedOperatingModesAttributeInteractionInfo); + Map readDoorLockEnableOneTouchLockingCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockEnableOneTouchLockingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readEnableOneTouchLockingAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnableOneTouchLockingCommandParams - ); - readDoorLockInteractionInfo.put("readEnableOneTouchLockingAttribute", readDoorLockEnableOneTouchLockingAttributeInteractionInfo); - Map readDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readEnablePrivacyModeButtonAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readDoorLockEnableOneTouchLockingCommandParams); + readDoorLockInteractionInfo.put( + "readEnableOneTouchLockingAttribute", + readDoorLockEnableOneTouchLockingAttributeInteractionInfo); + Map readDoorLockEnablePrivacyModeButtonCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readEnablePrivacyModeButtonAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readDoorLockEnablePrivacyModeButtonCommandParams - ); - readDoorLockInteractionInfo.put("readEnablePrivacyModeButtonAttribute", readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); - Map readDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readWrongCodeEntryLimitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockWrongCodeEntryLimitCommandParams - ); - readDoorLockInteractionInfo.put("readWrongCodeEntryLimitAttribute", readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); - Map readDoorLockAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readAttributeListAttribute( - ( ChipClusters.DoorLockCluster.AttributeListAttributeCallback - ) callback - ); - }, + readDoorLockEnablePrivacyModeButtonCommandParams); + readDoorLockInteractionInfo.put( + "readEnablePrivacyModeButtonAttribute", + readDoorLockEnablePrivacyModeButtonAttributeInteractionInfo); + Map readDoorLockWrongCodeEntryLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockWrongCodeEntryLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readWrongCodeEntryLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockWrongCodeEntryLimitCommandParams); + readDoorLockInteractionInfo.put( + "readWrongCodeEntryLimitAttribute", + readDoorLockWrongCodeEntryLimitAttributeInteractionInfo); + Map readDoorLockAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.DoorLockCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDoorLockClusterAttributeListAttributeCallback(), - readDoorLockAttributeListCommandParams - ); - readDoorLockInteractionInfo.put("readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); - Map readDoorLockClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.DoorLockCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readDoorLockClusterRevisionCommandParams - ); - readDoorLockInteractionInfo.put("readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("doorLock", readDoorLockInteractionInfo); - Map readElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readElectricalMeasurementMeasurementTypeCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readMeasurementTypeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readDoorLockAttributeListCommandParams); + readDoorLockInteractionInfo.put( + "readAttributeListAttribute", readDoorLockAttributeListAttributeInteractionInfo); + Map readDoorLockClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readDoorLockClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.DoorLockCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readDoorLockClusterRevisionCommandParams); + readDoorLockInteractionInfo.put( + "readClusterRevisionAttribute", readDoorLockClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("doorLock", readDoorLockInteractionInfo); + Map readElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readElectricalMeasurementMeasurementTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementMeasurementTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readMeasurementTypeAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementMeasurementTypeCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readMeasurementTypeAttribute", readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); - Map readElectricalMeasurementTotalActivePowerCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readTotalActivePowerAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readElectricalMeasurementMeasurementTypeCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readMeasurementTypeAttribute", + readElectricalMeasurementMeasurementTypeAttributeInteractionInfo); + Map readElectricalMeasurementTotalActivePowerCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementTotalActivePowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readTotalActivePowerAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readElectricalMeasurementTotalActivePowerCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readTotalActivePowerAttribute", readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); - Map readElectricalMeasurementRmsVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readRmsVoltageAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementRmsVoltageCommandParams - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.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 - ); - readElectricalMeasurementInteractionInfo.put("readActivePowerMaxAttribute", readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); - Map readElectricalMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), - readElectricalMeasurementAttributeListCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readAttributeListAttribute", readElectricalMeasurementAttributeListAttributeInteractionInfo); - Map readElectricalMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ElectricalMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readElectricalMeasurementClusterRevisionCommandParams - ); - readElectricalMeasurementInteractionInfo.put("readClusterRevisionAttribute", readElectricalMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("electricalMeasurement", readElectricalMeasurementInteractionInfo); - Map readEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - Map readEthernetNetworkDiagnosticsPHYRateCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPHYRateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readEthernetNetworkDiagnosticsPHYRateCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFullDuplexAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readElectricalMeasurementTotalActivePowerCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readTotalActivePowerAttribute", + readElectricalMeasurementTotalActivePowerAttributeInteractionInfo); + Map readElectricalMeasurementRmsVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementRmsVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readRmsVoltageAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementRmsVoltageCommandParams); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.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); + readElectricalMeasurementInteractionInfo.put( + "readActivePowerMaxAttribute", + readElectricalMeasurementActivePowerMaxAttributeInteractionInfo); + Map readElectricalMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ElectricalMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedElectricalMeasurementClusterAttributeListAttributeCallback(), + readElectricalMeasurementAttributeListCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readElectricalMeasurementAttributeListAttributeInteractionInfo); + Map readElectricalMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readElectricalMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ElectricalMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readElectricalMeasurementClusterRevisionCommandParams); + readElectricalMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readElectricalMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("electricalMeasurement", readElectricalMeasurementInteractionInfo); + Map readEthernetNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + Map readEthernetNetworkDiagnosticsPHYRateCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readPHYRateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readEthernetNetworkDiagnosticsPHYRateCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readPHYRateAttribute", readEthernetNetworkDiagnosticsPHYRateAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsFullDuplexCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readFullDuplexAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readEthernetNetworkDiagnosticsFullDuplexCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readFullDuplexAttribute", readEthernetNetworkDiagnosticsFullDuplexAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPacketRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsFullDuplexCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readPacketRxCountAttribute", readEthernetNetworkDiagnosticsPacketRxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsPacketTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readPacketTxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsPacketRxCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readPacketTxCountAttribute", readEthernetNetworkDiagnosticsPacketTxCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTxErrCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readTxErrCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsPacketTxCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readTxErrCountAttribute", readEthernetNetworkDiagnosticsTxErrCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCollisionCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCollisionCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsTxErrCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readCollisionCountAttribute", readEthernetNetworkDiagnosticsCollisionCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsCollisionCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readCarrierDetectAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsOverrunCountCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readOverrunCountAttribute", + readEthernetNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsCarrierDetectCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readCarrierDetectAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readEthernetNetworkDiagnosticsCarrierDetectCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readCarrierDetectAttribute", readEthernetNetworkDiagnosticsCarrierDetectAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsTimeSinceResetCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readTimeSinceResetAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsCarrierDetectCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readTimeSinceResetAttribute", readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.EthernetNetworkDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readEthernetNetworkDiagnosticsAttributeListCommandParams - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readAttributeListAttribute", readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readEthernetNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readEthernetNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readEthernetNetworkDiagnosticsTimeSinceResetCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readTimeSinceResetAttribute", + readEthernetNetworkDiagnosticsTimeSinceResetAttributeInteractionInfo); + Map readEthernetNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readEthernetNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.EthernetNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.EthernetNetworkDiagnosticsCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedEthernetNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readEthernetNetworkDiagnosticsAttributeListCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.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 - ); - readEthernetNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo); - Map readFixedLabelInteractionInfo = new LinkedHashMap<>(); - Map readFixedLabelLabelListCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelLabelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readLabelListAttribute( - ( ChipClusters.FixedLabelCluster.LabelListAttributeCallback - ) callback - ); - }, + readEthernetNetworkDiagnosticsFeatureMapCommandParams); + readEthernetNetworkDiagnosticsInteractionInfo.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); + readEthernetNetworkDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readEthernetNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "ethernetNetworkDiagnostics", readEthernetNetworkDiagnosticsInteractionInfo); + Map readFixedLabelInteractionInfo = 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 - ); - readFixedLabelInteractionInfo.put("readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); - Map readFixedLabelAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readAttributeListAttribute( - ( ChipClusters.FixedLabelCluster.AttributeListAttributeCallback - ) callback - ); - }, + readFixedLabelLabelListCommandParams); + readFixedLabelInteractionInfo.put( + "readLabelListAttribute", readFixedLabelLabelListAttributeInteractionInfo); + Map readFixedLabelAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.FixedLabelCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedFixedLabelClusterAttributeListAttributeCallback(), - readFixedLabelAttributeListCommandParams - ); - readFixedLabelInteractionInfo.put("readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); - Map readFixedLabelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FixedLabelCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFixedLabelClusterRevisionCommandParams - ); - readFixedLabelInteractionInfo.put("readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("fixedLabel", readFixedLabelInteractionInfo); - Map readFlowMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readFlowMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMeasuredValueCommandParams - ); - readFlowMeasurementInteractionInfo.put("readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMinMeasuredValueCommandParams - ); - readFlowMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readFlowMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementMaxMeasuredValueCommandParams - ); - readFlowMeasurementInteractionInfo.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 - ); - readFlowMeasurementInteractionInfo.put("readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); - Map readFlowMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), - readFlowMeasurementAttributeListCommandParams - ); - readFlowMeasurementInteractionInfo.put("readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); - Map readFlowMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.FlowMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readFlowMeasurementClusterRevisionCommandParams - ); - readFlowMeasurementInteractionInfo.put("readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("flowMeasurement", readFlowMeasurementInteractionInfo); - Map readGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readBreadcrumbAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readFixedLabelAttributeListCommandParams); + readFixedLabelInteractionInfo.put( + "readAttributeListAttribute", readFixedLabelAttributeListAttributeInteractionInfo); + Map readFixedLabelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readFixedLabelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FixedLabelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFixedLabelClusterRevisionCommandParams); + readFixedLabelInteractionInfo.put( + "readClusterRevisionAttribute", readFixedLabelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("fixedLabel", readFixedLabelInteractionInfo); + Map readFlowMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readFlowMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMeasuredValueCommandParams); + readFlowMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", readFlowMeasurementMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMinMeasuredValueCommandParams); + readFlowMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readFlowMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readFlowMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementMaxMeasuredValueCommandParams); + readFlowMeasurementInteractionInfo.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); + readFlowMeasurementInteractionInfo.put( + "readToleranceAttribute", readFlowMeasurementToleranceAttributeInteractionInfo); + Map readFlowMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.FlowMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedFlowMeasurementClusterAttributeListAttributeCallback(), + readFlowMeasurementAttributeListCommandParams); + readFlowMeasurementInteractionInfo.put( + "readAttributeListAttribute", readFlowMeasurementAttributeListAttributeInteractionInfo); + Map readFlowMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readFlowMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.FlowMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readFlowMeasurementClusterRevisionCommandParams); + readFlowMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", readFlowMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("flowMeasurement", readFlowMeasurementInteractionInfo); + Map readGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readGeneralCommissioningBreadcrumbCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBreadcrumbAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readBreadcrumbAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readGeneralCommissioningBreadcrumbCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); - Map readGeneralCommissioningBasicCommissioningInfoListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readBasicCommissioningInfoListAttribute( - ( ChipClusters.GeneralCommissioningCluster.BasicCommissioningInfoListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback(), - readGeneralCommissioningBasicCommissioningInfoListCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readBasicCommissioningInfoListAttribute", readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo); - Map readGeneralCommissioningRegulatoryConfigCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readRegulatoryConfigAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningRegulatoryConfigCommandParams - ); - readGeneralCommissioningInteractionInfo.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 - ); - readGeneralCommissioningInteractionInfo.put("readLocationCapabilityAttribute", readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); - Map readGeneralCommissioningAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), - readGeneralCommissioningAttributeListCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readAttributeListAttribute", readGeneralCommissioningAttributeListAttributeInteractionInfo); - Map readGeneralCommissioningClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralCommissioningCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralCommissioningClusterRevisionCommandParams - ); - readGeneralCommissioningInteractionInfo.put("readClusterRevisionAttribute", readGeneralCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("generalCommissioning", readGeneralCommissioningInteractionInfo); - Map readGeneralDiagnosticsInteractionInfo = 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 - ); - readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readRebootCountAttribute", readGeneralDiagnosticsRebootCountAttributeInteractionInfo); - Map readGeneralDiagnosticsUpTimeCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsUpTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readUpTimeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readGeneralCommissioningBreadcrumbCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readBreadcrumbAttribute", readGeneralCommissioningBreadcrumbAttributeInteractionInfo); + Map + readGeneralCommissioningBasicCommissioningInfoListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readBasicCommissioningInfoListAttribute( + (ChipClusters.GeneralCommissioningCluster + .BasicCommissioningInfoListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralCommissioningClusterBasicCommissioningInfoListAttributeCallback(), + readGeneralCommissioningBasicCommissioningInfoListCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readBasicCommissioningInfoListAttribute", + readGeneralCommissioningBasicCommissioningInfoListAttributeInteractionInfo); + Map readGeneralCommissioningRegulatoryConfigCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningRegulatoryConfigAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readRegulatoryConfigAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningRegulatoryConfigCommandParams); + readGeneralCommissioningInteractionInfo.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); + readGeneralCommissioningInteractionInfo.put( + "readLocationCapabilityAttribute", + readGeneralCommissioningLocationCapabilityAttributeInteractionInfo); + Map readGeneralCommissioningAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GeneralCommissioningCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralCommissioningClusterAttributeListAttributeCallback(), + readGeneralCommissioningAttributeListCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readAttributeListAttribute", + readGeneralCommissioningAttributeListAttributeInteractionInfo); + Map readGeneralCommissioningClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralCommissioningClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralCommissioningCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralCommissioningClusterRevisionCommandParams); + readGeneralCommissioningInteractionInfo.put( + "readClusterRevisionAttribute", + readGeneralCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalCommissioning", readGeneralCommissioningInteractionInfo); + Map readGeneralDiagnosticsInteractionInfo = 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); + readGeneralDiagnosticsInteractionInfo.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); + readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readUpTimeAttribute", readGeneralDiagnosticsUpTimeAttributeInteractionInfo); - Map readGeneralDiagnosticsTotalOperationalHoursCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readTotalOperationalHoursAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readGeneralDiagnosticsUpTimeCommandParams); + readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readTotalOperationalHoursAttribute", readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); - Map readGeneralDiagnosticsBootReasonsCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsBootReasonsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readBootReasonsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsBootReasonsCommandParams - ); - readGeneralDiagnosticsInteractionInfo.put("readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeInteractionInfo); - Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readActiveHardwareFaultsAttribute( - ( ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), - readGeneralDiagnosticsActiveHardwareFaultsCommandParams - ); - readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.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 - ); - readGeneralDiagnosticsInteractionInfo.put("readActiveNetworkFaultsAttribute", readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); - Map readGeneralDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), - readGeneralDiagnosticsAttributeListCommandParams - ); - readGeneralDiagnosticsInteractionInfo.put("readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); - Map readGeneralDiagnosticsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GeneralDiagnosticsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGeneralDiagnosticsClusterRevisionCommandParams - ); - readGeneralDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo); - Map readGroupKeyManagementInteractionInfo = 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 - ); - readGroupKeyManagementInteractionInfo.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 - ); - readGroupKeyManagementInteractionInfo.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 - ); - readGroupKeyManagementInteractionInfo.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 - ); - readGroupKeyManagementInteractionInfo.put("readMaxGroupKeysPerFabricAttribute", readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); - Map readGroupKeyManagementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), - readGroupKeyManagementAttributeListCommandParams - ); - readGroupKeyManagementInteractionInfo.put("readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); - Map readGroupKeyManagementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupKeyManagementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupKeyManagementClusterRevisionCommandParams - ); - readGroupKeyManagementInteractionInfo.put("readClusterRevisionAttribute", readGroupKeyManagementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("groupKeyManagement", readGroupKeyManagementInteractionInfo); - Map readGroupsInteractionInfo = new LinkedHashMap<>(); - Map readGroupsNameSupportCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsNameSupportAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readNameSupportAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsNameSupportCommandParams - ); - readGroupsInteractionInfo.put("readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); - Map readGroupsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.GroupsCluster.AttributeListAttributeCallback - ) callback - ); - }, + readGeneralDiagnosticsTotalOperationalHoursCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readTotalOperationalHoursAttribute", + readGeneralDiagnosticsTotalOperationalHoursAttributeInteractionInfo); + Map readGeneralDiagnosticsBootReasonsCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsBootReasonsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readBootReasonsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsBootReasonsCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readBootReasonsAttribute", readGeneralDiagnosticsBootReasonsAttributeInteractionInfo); + Map readGeneralDiagnosticsActiveHardwareFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsActiveHardwareFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readActiveHardwareFaultsAttribute( + (ChipClusters.GeneralDiagnosticsCluster.ActiveHardwareFaultsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterActiveHardwareFaultsAttributeCallback(), + readGeneralDiagnosticsActiveHardwareFaultsCommandParams); + readGeneralDiagnosticsInteractionInfo.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); + readGeneralDiagnosticsInteractionInfo.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); + readGeneralDiagnosticsInteractionInfo.put( + "readActiveNetworkFaultsAttribute", + readGeneralDiagnosticsActiveNetworkFaultsAttributeInteractionInfo); + Map readGeneralDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GeneralDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGeneralDiagnosticsClusterAttributeListAttributeCallback(), + readGeneralDiagnosticsAttributeListCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readAttributeListAttribute", readGeneralDiagnosticsAttributeListAttributeInteractionInfo); + Map readGeneralDiagnosticsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GeneralDiagnosticsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGeneralDiagnosticsClusterRevisionCommandParams); + readGeneralDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readGeneralDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("generalDiagnostics", readGeneralDiagnosticsInteractionInfo); + Map readGroupKeyManagementInteractionInfo = 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); + readGroupKeyManagementInteractionInfo.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); + readGroupKeyManagementInteractionInfo.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); + readGroupKeyManagementInteractionInfo.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); + readGroupKeyManagementInteractionInfo.put( + "readMaxGroupKeysPerFabricAttribute", + readGroupKeyManagementMaxGroupKeysPerFabricAttributeInteractionInfo); + Map readGroupKeyManagementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GroupKeyManagementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedGroupKeyManagementClusterAttributeListAttributeCallback(), + readGroupKeyManagementAttributeListCommandParams); + readGroupKeyManagementInteractionInfo.put( + "readAttributeListAttribute", readGroupKeyManagementAttributeListAttributeInteractionInfo); + Map readGroupKeyManagementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupKeyManagementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupKeyManagementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupKeyManagementClusterRevisionCommandParams); + readGroupKeyManagementInteractionInfo.put( + "readClusterRevisionAttribute", + readGroupKeyManagementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groupKeyManagement", readGroupKeyManagementInteractionInfo); + Map readGroupsInteractionInfo = new LinkedHashMap<>(); + Map readGroupsNameSupportCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsNameSupportAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readNameSupportAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsNameSupportCommandParams); + readGroupsInteractionInfo.put( + "readNameSupportAttribute", readGroupsNameSupportAttributeInteractionInfo); + Map readGroupsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.GroupsCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedGroupsClusterAttributeListAttributeCallback(), - readGroupsAttributeListCommandParams - ); - readGroupsInteractionInfo.put("readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); - Map readGroupsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.GroupsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readGroupsClusterRevisionCommandParams - ); - readGroupsInteractionInfo.put("readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("groups", readGroupsInteractionInfo); - Map readIdentifyInteractionInfo = new LinkedHashMap<>(); - Map readIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readIdentifyTimeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyIdentifyTimeCommandParams - ); - readIdentifyInteractionInfo.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 - ); - readIdentifyInteractionInfo.put("readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); - Map readIdentifyAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readAttributeListAttribute( - ( ChipClusters.IdentifyCluster.AttributeListAttributeCallback - ) callback - ); - }, + readGroupsAttributeListCommandParams); + readGroupsInteractionInfo.put( + "readAttributeListAttribute", readGroupsAttributeListAttributeInteractionInfo); + Map readGroupsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readGroupsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.GroupsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readGroupsClusterRevisionCommandParams); + readGroupsInteractionInfo.put( + "readClusterRevisionAttribute", readGroupsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("groups", readGroupsInteractionInfo); + Map readIdentifyInteractionInfo = new LinkedHashMap<>(); + Map readIdentifyIdentifyTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyIdentifyTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readIdentifyTimeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyIdentifyTimeCommandParams); + readIdentifyInteractionInfo.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); + readIdentifyInteractionInfo.put( + "readIdentifyTypeAttribute", readIdentifyIdentifyTypeAttributeInteractionInfo); + Map readIdentifyAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.IdentifyCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedIdentifyClusterAttributeListAttributeCallback(), - readIdentifyAttributeListCommandParams - ); - readIdentifyInteractionInfo.put("readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); - Map readIdentifyClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IdentifyCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIdentifyClusterRevisionCommandParams - ); - readIdentifyInteractionInfo.put("readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("identify", readIdentifyInteractionInfo); - Map readIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readIlluminanceMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMeasuredValueAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMeasuredValueCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readMeasuredValueAttribute", readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMinMeasuredValueCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementMaxMeasuredValueCommandParams - ); - readIlluminanceMeasurementInteractionInfo.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 - ); - readIlluminanceMeasurementInteractionInfo.put("readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); - Map readIlluminanceMeasurementLightSensorTypeCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readLightSensorTypeAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementLightSensorTypeCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readLightSensorTypeAttribute", readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); - Map readIlluminanceMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), - readIlluminanceMeasurementAttributeListCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readAttributeListAttribute", readIlluminanceMeasurementAttributeListAttributeInteractionInfo); - Map readIlluminanceMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.IlluminanceMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readIlluminanceMeasurementClusterRevisionCommandParams - ); - readIlluminanceMeasurementInteractionInfo.put("readClusterRevisionAttribute", readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo); - Map readKeypadInputInteractionInfo = new LinkedHashMap<>(); - Map readKeypadInputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readAttributeListAttribute( - ( ChipClusters.KeypadInputCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), - readKeypadInputAttributeListCommandParams - ); - readKeypadInputInteractionInfo.put("readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); - Map readKeypadInputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.KeypadInputCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readKeypadInputClusterRevisionCommandParams - ); - readKeypadInputInteractionInfo.put("readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("keypadInput", readKeypadInputInteractionInfo); - Map readLevelControlInteractionInfo = new LinkedHashMap<>(); - Map readLevelControlCurrentLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readCurrentLevelAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlCurrentLevelCommandParams - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.put("readOnOffTransitionTimeAttribute", readLevelControlOnOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlOnLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOnLevelAttribute( - ( ChipClusters.LevelControlCluster.OnLevelAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnLevelCommandParams - ); - readLevelControlInteractionInfo.put("readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); - Map readLevelControlOnTransitionTimeCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOnTransitionTimeAttribute( - ( ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOnTransitionTimeCommandParams - ); - readLevelControlInteractionInfo.put("readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); - Map readLevelControlOffTransitionTimeCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readOffTransitionTimeAttribute( - ( ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlOffTransitionTimeCommandParams - ); - readLevelControlInteractionInfo.put("readOffTransitionTimeAttribute", readLevelControlOffTransitionTimeAttributeInteractionInfo); - Map readLevelControlDefaultMoveRateCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readDefaultMoveRateAttribute( - ( ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlDefaultMoveRateCommandParams - ); - readLevelControlInteractionInfo.put("readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); - Map readLevelControlStartUpCurrentLevelCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readStartUpCurrentLevelAttribute( - ( ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLevelControlStartUpCurrentLevelCommandParams - ); - readLevelControlInteractionInfo.put("readStartUpCurrentLevelAttribute", readLevelControlStartUpCurrentLevelAttributeInteractionInfo); - Map readLevelControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.LevelControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), - readLevelControlAttributeListCommandParams - ); - readLevelControlInteractionInfo.put("readAttributeListAttribute", readLevelControlAttributeListAttributeInteractionInfo); - Map readLevelControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readLevelControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LevelControlCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readIdentifyAttributeListCommandParams); + readIdentifyInteractionInfo.put( + "readAttributeListAttribute", readIdentifyAttributeListAttributeInteractionInfo); + Map readIdentifyClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readIdentifyClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IdentifyCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIdentifyClusterRevisionCommandParams); + readIdentifyInteractionInfo.put( + "readClusterRevisionAttribute", readIdentifyClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("identify", readIdentifyInteractionInfo); + Map readIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readIlluminanceMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MeasuredValueAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMeasuredValueCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", + readIlluminanceMeasurementMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMinMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MinMeasuredValueAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMinMeasuredValueCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readIlluminanceMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readIlluminanceMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute( + (ChipClusters.IlluminanceMeasurementCluster.MaxMeasuredValueAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementMaxMeasuredValueCommandParams); + readIlluminanceMeasurementInteractionInfo.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); + readIlluminanceMeasurementInteractionInfo.put( + "readToleranceAttribute", readIlluminanceMeasurementToleranceAttributeInteractionInfo); + Map readIlluminanceMeasurementLightSensorTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readLightSensorTypeAttribute( + (ChipClusters.IlluminanceMeasurementCluster.LightSensorTypeAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementLightSensorTypeCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readLightSensorTypeAttribute", + readIlluminanceMeasurementLightSensorTypeAttributeInteractionInfo); + Map readIlluminanceMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.IlluminanceMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedIlluminanceMeasurementClusterAttributeListAttributeCallback(), + readIlluminanceMeasurementAttributeListCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readIlluminanceMeasurementAttributeListAttributeInteractionInfo); + Map readIlluminanceMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.IlluminanceMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readIlluminanceMeasurementClusterRevisionCommandParams); + readIlluminanceMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readIlluminanceMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("illuminanceMeasurement", readIlluminanceMeasurementInteractionInfo); + Map readKeypadInputInteractionInfo = new LinkedHashMap<>(); + Map readKeypadInputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.KeypadInputCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedKeypadInputClusterAttributeListAttributeCallback(), + readKeypadInputAttributeListCommandParams); + readKeypadInputInteractionInfo.put( + "readAttributeListAttribute", readKeypadInputAttributeListAttributeInteractionInfo); + Map readKeypadInputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readKeypadInputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.KeypadInputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readKeypadInputClusterRevisionCommandParams); + readKeypadInputInteractionInfo.put( + "readClusterRevisionAttribute", readKeypadInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("keypadInput", readKeypadInputInteractionInfo); + Map readLevelControlInteractionInfo = new LinkedHashMap<>(); + Map readLevelControlCurrentLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlCurrentLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readCurrentLevelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlCurrentLevelCommandParams); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.put( + "readOnOffTransitionTimeAttribute", + readLevelControlOnOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlOnLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOnLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOnLevelAttribute( + (ChipClusters.LevelControlCluster.OnLevelAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnLevelCommandParams); + readLevelControlInteractionInfo.put( + "readOnLevelAttribute", readLevelControlOnLevelAttributeInteractionInfo); + Map readLevelControlOnTransitionTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOnTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOnTransitionTimeAttribute( + (ChipClusters.LevelControlCluster.OnTransitionTimeAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOnTransitionTimeCommandParams); + readLevelControlInteractionInfo.put( + "readOnTransitionTimeAttribute", readLevelControlOnTransitionTimeAttributeInteractionInfo); + Map readLevelControlOffTransitionTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlOffTransitionTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readOffTransitionTimeAttribute( + (ChipClusters.LevelControlCluster.OffTransitionTimeAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlOffTransitionTimeCommandParams); + readLevelControlInteractionInfo.put( + "readOffTransitionTimeAttribute", + readLevelControlOffTransitionTimeAttributeInteractionInfo); + Map readLevelControlDefaultMoveRateCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlDefaultMoveRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readDefaultMoveRateAttribute( + (ChipClusters.LevelControlCluster.DefaultMoveRateAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlDefaultMoveRateCommandParams); + readLevelControlInteractionInfo.put( + "readDefaultMoveRateAttribute", readLevelControlDefaultMoveRateAttributeInteractionInfo); + Map readLevelControlStartUpCurrentLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlStartUpCurrentLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readStartUpCurrentLevelAttribute( + (ChipClusters.LevelControlCluster.StartUpCurrentLevelAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLevelControlStartUpCurrentLevelCommandParams); + readLevelControlInteractionInfo.put( + "readStartUpCurrentLevelAttribute", + readLevelControlStartUpCurrentLevelAttributeInteractionInfo); + Map readLevelControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readLevelControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LevelControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.LevelControlCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedLevelControlClusterAttributeListAttributeCallback(), + readLevelControlAttributeListCommandParams); + readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.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 - ); - readLevelControlInteractionInfo.put("readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("levelControl", readLevelControlInteractionInfo); - Map readLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); - Map readLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readActiveLocaleAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readLevelControlFeatureMapCommandParams); + readLevelControlInteractionInfo.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); + readLevelControlInteractionInfo.put( + "readClusterRevisionAttribute", readLevelControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("levelControl", readLevelControlInteractionInfo); + Map readLocalizationConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map readLocalizationConfigurationActiveLocaleCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationActiveLocaleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readActiveLocaleAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readLocalizationConfigurationActiveLocaleCommandParams - ); - readLocalizationConfigurationInteractionInfo.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 - ); - readLocalizationConfigurationInteractionInfo.put("readSupportedLocalesAttribute", readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); - Map readLocalizationConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LocalizationConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLocalizationConfigurationClusterRevisionCommandParams - ); - readLocalizationConfigurationInteractionInfo.put("readClusterRevisionAttribute", readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("localizationConfiguration", readLocalizationConfigurationInteractionInfo); - Map readLowPowerInteractionInfo = new LinkedHashMap<>(); - Map readLowPowerAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readAttributeListAttribute( - ( ChipClusters.LowPowerCluster.AttributeListAttributeCallback - ) callback - ); - }, + readLocalizationConfigurationActiveLocaleCommandParams); + readLocalizationConfigurationInteractionInfo.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); + readLocalizationConfigurationInteractionInfo.put( + "readSupportedLocalesAttribute", + readLocalizationConfigurationSupportedLocalesAttributeInteractionInfo); + Map readLocalizationConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readLocalizationConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LocalizationConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLocalizationConfigurationClusterRevisionCommandParams); + readLocalizationConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readLocalizationConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("localizationConfiguration", readLocalizationConfigurationInteractionInfo); + Map readLowPowerInteractionInfo = new LinkedHashMap<>(); + Map readLowPowerAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.LowPowerCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLowPowerClusterAttributeListAttributeCallback(), - readLowPowerAttributeListCommandParams - ); - readLowPowerInteractionInfo.put("readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); - Map readLowPowerClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.LowPowerCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readLowPowerClusterRevisionCommandParams - ); - readLowPowerInteractionInfo.put("readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("lowPower", readLowPowerInteractionInfo); - Map readMediaInputInteractionInfo = new LinkedHashMap<>(); - Map readMediaInputMediaInputListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputMediaInputListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readMediaInputListAttribute( - ( ChipClusters.MediaInputCluster.MediaInputListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaInputClusterMediaInputListAttributeCallback(), - readMediaInputMediaInputListCommandParams - ); - readMediaInputInteractionInfo.put("readMediaInputListAttribute", readMediaInputMediaInputListAttributeInteractionInfo); - Map readMediaInputCurrentMediaInputCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputCurrentMediaInputAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readCurrentMediaInputAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputCurrentMediaInputCommandParams - ); - readMediaInputInteractionInfo.put("readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeInteractionInfo); - Map readMediaInputAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readAttributeListAttribute( - ( ChipClusters.MediaInputCluster.AttributeListAttributeCallback - ) callback - ); - }, + readLowPowerAttributeListCommandParams); + readLowPowerInteractionInfo.put( + "readAttributeListAttribute", readLowPowerAttributeListAttributeInteractionInfo); + Map readLowPowerClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readLowPowerClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.LowPowerCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readLowPowerClusterRevisionCommandParams); + readLowPowerInteractionInfo.put( + "readClusterRevisionAttribute", readLowPowerClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("lowPower", readLowPowerInteractionInfo); + Map readMediaInputInteractionInfo = new LinkedHashMap<>(); + Map readMediaInputMediaInputListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputMediaInputListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readMediaInputListAttribute( + (ChipClusters.MediaInputCluster.MediaInputListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedMediaInputClusterMediaInputListAttributeCallback(), + readMediaInputMediaInputListCommandParams); + readMediaInputInteractionInfo.put( + "readMediaInputListAttribute", readMediaInputMediaInputListAttributeInteractionInfo); + Map readMediaInputCurrentMediaInputCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputCurrentMediaInputAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readCurrentMediaInputAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputCurrentMediaInputCommandParams); + readMediaInputInteractionInfo.put( + "readCurrentMediaInputAttribute", readMediaInputCurrentMediaInputAttributeInteractionInfo); + Map readMediaInputAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.MediaInputCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedMediaInputClusterAttributeListAttributeCallback(), - readMediaInputAttributeListCommandParams - ); - readMediaInputInteractionInfo.put("readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); - Map readMediaInputClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaInputCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaInputClusterRevisionCommandParams - ); - readMediaInputInteractionInfo.put("readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("mediaInput", readMediaInputInteractionInfo); - Map readMediaPlaybackInteractionInfo = new LinkedHashMap<>(); - Map readMediaPlaybackPlaybackStateCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readPlaybackStateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackPlaybackStateCommandParams - ); - readMediaPlaybackInteractionInfo.put("readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeInteractionInfo); - Map readMediaPlaybackStartTimeCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readStartTimeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaInputAttributeListCommandParams); + readMediaInputInteractionInfo.put( + "readAttributeListAttribute", readMediaInputAttributeListAttributeInteractionInfo); + Map readMediaInputClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaInputClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaInputCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaInputClusterRevisionCommandParams); + readMediaInputInteractionInfo.put( + "readClusterRevisionAttribute", readMediaInputClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaInput", readMediaInputInteractionInfo); + Map readMediaPlaybackInteractionInfo = new LinkedHashMap<>(); + Map readMediaPlaybackPlaybackStateCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackPlaybackStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readPlaybackStateAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackPlaybackStateCommandParams); + readMediaPlaybackInteractionInfo.put( + "readPlaybackStateAttribute", readMediaPlaybackPlaybackStateAttributeInteractionInfo); + Map readMediaPlaybackStartTimeCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackStartTimeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readStartTimeAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackStartTimeCommandParams - ); - readMediaPlaybackInteractionInfo.put("readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); - Map readMediaPlaybackDurationCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readDurationAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaPlaybackStartTimeCommandParams); + readMediaPlaybackInteractionInfo.put( + "readStartTimeAttribute", readMediaPlaybackStartTimeAttributeInteractionInfo); + Map readMediaPlaybackDurationCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackDurationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readDurationAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackDurationCommandParams - ); - readMediaPlaybackInteractionInfo.put("readDurationAttribute", readMediaPlaybackDurationAttributeInteractionInfo); - Map readMediaPlaybackPlaybackSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackPlaybackSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readPlaybackSpeedAttribute( - ( - ChipClusters.FloatAttributeCallback -) callback - ); - }, + readMediaPlaybackDurationCommandParams); + readMediaPlaybackInteractionInfo.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 - ); - readMediaPlaybackInteractionInfo.put("readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeEndCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeEndAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaPlaybackPlaybackSpeedCommandParams); + readMediaPlaybackInteractionInfo.put( + "readPlaybackSpeedAttribute", readMediaPlaybackPlaybackSpeedAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeEndCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeEndAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readSeekRangeEndAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackSeekRangeEndCommandParams - ); - readMediaPlaybackInteractionInfo.put("readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); - Map readMediaPlaybackSeekRangeStartCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readSeekRangeStartAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readMediaPlaybackSeekRangeEndCommandParams); + readMediaPlaybackInteractionInfo.put( + "readSeekRangeEndAttribute", readMediaPlaybackSeekRangeEndAttributeInteractionInfo); + Map readMediaPlaybackSeekRangeStartCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackSeekRangeStartAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readSeekRangeStartAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readMediaPlaybackSeekRangeStartCommandParams - ); - readMediaPlaybackInteractionInfo.put("readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); - Map readMediaPlaybackAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readAttributeListAttribute( - ( ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), - readMediaPlaybackAttributeListCommandParams - ); - readMediaPlaybackInteractionInfo.put("readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); - Map readMediaPlaybackClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.MediaPlaybackCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readMediaPlaybackClusterRevisionCommandParams - ); - readMediaPlaybackInteractionInfo.put("readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("mediaPlayback", readMediaPlaybackInteractionInfo); - Map readModeSelectInteractionInfo = new LinkedHashMap<>(); - Map readModeSelectCurrentModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readCurrentModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectCurrentModeCommandParams - ); - readModeSelectInteractionInfo.put("readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); - Map readModeSelectSupportedModesCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readSupportedModesAttribute( - ( ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), - readModeSelectSupportedModesCommandParams - ); - readModeSelectInteractionInfo.put("readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); - Map readModeSelectOnModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectOnModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readOnModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectOnModeCommandParams - ); - readModeSelectInteractionInfo.put("readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); - Map readModeSelectStartUpModeCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readStartUpModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectStartUpModeCommandParams - ); - readModeSelectInteractionInfo.put("readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); - Map readModeSelectDescriptionCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readDescriptionAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readMediaPlaybackSeekRangeStartCommandParams); + readMediaPlaybackInteractionInfo.put( + "readSeekRangeStartAttribute", readMediaPlaybackSeekRangeStartAttributeInteractionInfo); + Map readMediaPlaybackAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.MediaPlaybackCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedMediaPlaybackClusterAttributeListAttributeCallback(), + readMediaPlaybackAttributeListCommandParams); + readMediaPlaybackInteractionInfo.put( + "readAttributeListAttribute", readMediaPlaybackAttributeListAttributeInteractionInfo); + Map readMediaPlaybackClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readMediaPlaybackClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.MediaPlaybackCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readMediaPlaybackClusterRevisionCommandParams); + readMediaPlaybackInteractionInfo.put( + "readClusterRevisionAttribute", readMediaPlaybackClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("mediaPlayback", readMediaPlaybackInteractionInfo); + Map readModeSelectInteractionInfo = new LinkedHashMap<>(); + Map readModeSelectCurrentModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectCurrentModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readCurrentModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectCurrentModeCommandParams); + readModeSelectInteractionInfo.put( + "readCurrentModeAttribute", readModeSelectCurrentModeAttributeInteractionInfo); + Map readModeSelectSupportedModesCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectSupportedModesAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readSupportedModesAttribute( + (ChipClusters.ModeSelectCluster.SupportedModesAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedModeSelectClusterSupportedModesAttributeCallback(), + readModeSelectSupportedModesCommandParams); + readModeSelectInteractionInfo.put( + "readSupportedModesAttribute", readModeSelectSupportedModesAttributeInteractionInfo); + Map readModeSelectOnModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectOnModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readOnModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectOnModeCommandParams); + readModeSelectInteractionInfo.put( + "readOnModeAttribute", readModeSelectOnModeAttributeInteractionInfo); + Map readModeSelectStartUpModeCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectStartUpModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readStartUpModeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectStartUpModeCommandParams); + readModeSelectInteractionInfo.put( + "readStartUpModeAttribute", readModeSelectStartUpModeAttributeInteractionInfo); + Map readModeSelectDescriptionCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectDescriptionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readDescriptionAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readModeSelectDescriptionCommandParams - ); - readModeSelectInteractionInfo.put("readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); - Map readModeSelectAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ModeSelectCluster.AttributeListAttributeCallback - ) callback - ); - }, + readModeSelectDescriptionCommandParams); + readModeSelectInteractionInfo.put( + "readDescriptionAttribute", readModeSelectDescriptionAttributeInteractionInfo); + Map readModeSelectAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ModeSelectCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedModeSelectClusterAttributeListAttributeCallback(), - readModeSelectAttributeListCommandParams - ); - readModeSelectInteractionInfo.put("readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); - Map readModeSelectClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ModeSelectCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readModeSelectClusterRevisionCommandParams - ); - readModeSelectInteractionInfo.put("readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("modeSelect", readModeSelectInteractionInfo); - Map readNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map readNetworkCommissioningMaxNetworksCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readMaxNetworksAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningMaxNetworksCommandParams - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.put("readConnectMaxTimeSecondsAttribute", readNetworkCommissioningConnectMaxTimeSecondsAttributeInteractionInfo); - Map readNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readInterfaceEnabledAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readModeSelectAttributeListCommandParams); + readModeSelectInteractionInfo.put( + "readAttributeListAttribute", readModeSelectAttributeListAttributeInteractionInfo); + Map readModeSelectClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readModeSelectClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ModeSelectCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readModeSelectClusterRevisionCommandParams); + readModeSelectInteractionInfo.put( + "readClusterRevisionAttribute", readModeSelectClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("modeSelect", readModeSelectInteractionInfo); + Map readNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); + Map readNetworkCommissioningMaxNetworksCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningMaxNetworksAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readMaxNetworksAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningMaxNetworksCommandParams); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.put("readInterfaceEnabledAttribute", readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkingStatusCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkingStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readNetworkCommissioningLastNetworkingStatusCommandParams - ); - readNetworkCommissioningInteractionInfo.put("readLastNetworkingStatusAttribute", readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); - Map readNetworkCommissioningLastNetworkIDCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastNetworkIDAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readNetworkCommissioningInterfaceEnabledCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readInterfaceEnabledAttribute", + readNetworkCommissioningInterfaceEnabledAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkingStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastNetworkingStatusAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readNetworkCommissioningLastNetworkingStatusCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readLastNetworkingStatusAttribute", + readNetworkCommissioningLastNetworkingStatusAttributeInteractionInfo); + Map readNetworkCommissioningLastNetworkIDCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastNetworkIDAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastNetworkIDAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readNetworkCommissioningLastNetworkIDCommandParams - ); - readNetworkCommissioningInteractionInfo.put("readLastNetworkIDAttribute", readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); - Map readNetworkCommissioningLastConnectErrorValueCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readLastConnectErrorValueAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readNetworkCommissioningLastNetworkIDCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readLastNetworkIDAttribute", + readNetworkCommissioningLastNetworkIDAttributeInteractionInfo); + Map readNetworkCommissioningLastConnectErrorValueCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readLastConnectErrorValueAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningLastConnectErrorValueCommandParams - ); - readNetworkCommissioningInteractionInfo.put("readLastConnectErrorValueAttribute", readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); - Map readNetworkCommissioningFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.NetworkCommissioningCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readNetworkCommissioningLastConnectErrorValueCommandParams); + readNetworkCommissioningInteractionInfo.put( + "readLastConnectErrorValueAttribute", + readNetworkCommissioningLastConnectErrorValueAttributeInteractionInfo); + Map readNetworkCommissioningFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readNetworkCommissioningFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.NetworkCommissioningCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readNetworkCommissioningFeatureMapCommandParams - ); - readNetworkCommissioningInteractionInfo.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 - ); - readNetworkCommissioningInteractionInfo.put("readClusterRevisionAttribute", readNetworkCommissioningClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("networkCommissioning", readNetworkCommissioningInteractionInfo); - Map readOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); - Map readOtaSoftwareUpdateProviderAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateProviderAttributeListCommandParams - ); - readOtaSoftwareUpdateProviderInteractionInfo.put("readAttributeListAttribute", readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateProviderClusterRevisionCommandParams - ); - readOtaSoftwareUpdateProviderInteractionInfo.put("readClusterRevisionAttribute", readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo); - Map readOtaSoftwareUpdateRequestorInteractionInfo = 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 - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readDefaultOtaProvidersAttribute", readOtaSoftwareUpdateRequestorDefaultOtaProvidersAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdatePossibleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdatePossibleAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readNetworkCommissioningFeatureMapCommandParams); + readNetworkCommissioningInteractionInfo.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); + readNetworkCommissioningInteractionInfo.put( + "readClusterRevisionAttribute", + readNetworkCommissioningClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("networkCommissioning", readNetworkCommissioningInteractionInfo); + Map readOtaSoftwareUpdateProviderInteractionInfo = + new LinkedHashMap<>(); + Map readOtaSoftwareUpdateProviderAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OtaSoftwareUpdateProviderCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateProviderClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateProviderAttributeListCommandParams); + readOtaSoftwareUpdateProviderInteractionInfo.put( + "readAttributeListAttribute", + readOtaSoftwareUpdateProviderAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateProviderClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateProviderCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateProviderClusterRevisionCommandParams); + readOtaSoftwareUpdateProviderInteractionInfo.put( + "readClusterRevisionAttribute", + readOtaSoftwareUpdateProviderClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("otaSoftwareUpdateProvider", readOtaSoftwareUpdateProviderInteractionInfo); + Map readOtaSoftwareUpdateRequestorInteractionInfo = + 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); + readOtaSoftwareUpdateRequestorInteractionInfo.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 - ); - readOtaSoftwareUpdateRequestorInteractionInfo.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 - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readUpdateStateAttribute", readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readUpdateStateProgressAttribute( - ( ChipClusters.OtaSoftwareUpdateRequestorCluster.UpdateStateProgressAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readUpdateStateProgressAttribute", readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OtaSoftwareUpdateRequestorCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), - readOtaSoftwareUpdateRequestorAttributeListCommandParams - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readAttributeListAttribute", readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); - Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOtaSoftwareUpdateRequestorClusterRevisionCommandParams - ); - readOtaSoftwareUpdateRequestorInteractionInfo.put("readClusterRevisionAttribute", readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo); - Map readOccupancySensingInteractionInfo = new LinkedHashMap<>(); - Map readOccupancySensingOccupancyCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readOccupancyAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingOccupancyCommandParams - ); - readOccupancySensingInteractionInfo.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 - ); - readOccupancySensingInteractionInfo.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 - ); - readOccupancySensingInteractionInfo.put("readOccupancySensorTypeBitmapAttribute", readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); - Map readOccupancySensingAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOccupancySensingClusterAttributeListAttributeCallback(), - readOccupancySensingAttributeListCommandParams - ); - readOccupancySensingInteractionInfo.put("readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); - Map readOccupancySensingClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OccupancySensingCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOccupancySensingClusterRevisionCommandParams - ); - readOccupancySensingInteractionInfo.put("readClusterRevisionAttribute", readOccupancySensingClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("occupancySensing", readOccupancySensingInteractionInfo); - Map readOnOffInteractionInfo = new LinkedHashMap<>(); - Map readOnOffOnOffCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffOnOffAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readOnOffAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readOtaSoftwareUpdateRequestorUpdatePossibleCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.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); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readUpdateStateAttribute", + readOtaSoftwareUpdateRequestorUpdateStateAttributeInteractionInfo); + Map + readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readUpdateStateProgressAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster + .UpdateStateProgressAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorUpdateStateProgressCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readUpdateStateProgressAttribute", + readOtaSoftwareUpdateRequestorUpdateStateProgressAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OtaSoftwareUpdateRequestorCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOtaSoftwareUpdateRequestorClusterAttributeListAttributeCallback(), + readOtaSoftwareUpdateRequestorAttributeListCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readAttributeListAttribute", + readOtaSoftwareUpdateRequestorAttributeListAttributeInteractionInfo); + Map readOtaSoftwareUpdateRequestorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OtaSoftwareUpdateRequestorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOtaSoftwareUpdateRequestorClusterRevisionCommandParams); + readOtaSoftwareUpdateRequestorInteractionInfo.put( + "readClusterRevisionAttribute", + readOtaSoftwareUpdateRequestorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "otaSoftwareUpdateRequestor", readOtaSoftwareUpdateRequestorInteractionInfo); + Map readOccupancySensingInteractionInfo = new LinkedHashMap<>(); + Map readOccupancySensingOccupancyCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingOccupancyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readOccupancyAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingOccupancyCommandParams); + readOccupancySensingInteractionInfo.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); + readOccupancySensingInteractionInfo.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); + readOccupancySensingInteractionInfo.put( + "readOccupancySensorTypeBitmapAttribute", + readOccupancySensingOccupancySensorTypeBitmapAttributeInteractionInfo); + Map readOccupancySensingAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OccupancySensingCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOccupancySensingClusterAttributeListAttributeCallback(), + readOccupancySensingAttributeListCommandParams); + readOccupancySensingInteractionInfo.put( + "readAttributeListAttribute", readOccupancySensingAttributeListAttributeInteractionInfo); + Map readOccupancySensingClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOccupancySensingClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OccupancySensingCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOccupancySensingClusterRevisionCommandParams); + readOccupancySensingInteractionInfo.put( + "readClusterRevisionAttribute", + readOccupancySensingClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("occupancySensing", readOccupancySensingInteractionInfo); + Map readOnOffInteractionInfo = new LinkedHashMap<>(); + Map readOnOffOnOffCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffOnOffAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readOnOffAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readOnOffOnOffCommandParams - ); - readOnOffInteractionInfo.put("readOnOffAttribute", readOnOffOnOffAttributeInteractionInfo); - Map readOnOffGlobalSceneControlCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffGlobalSceneControlAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readGlobalSceneControlAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readOnOffOnOffCommandParams); + readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.put("readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); - Map readOnOffStartUpOnOffCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readStartUpOnOffAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffStartUpOnOffCommandParams - ); - readOnOffInteractionInfo.put("readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); - Map readOnOffAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OnOffCluster.AttributeListAttributeCallback - ) callback - ); - }, + readOnOffGlobalSceneControlCommandParams); + readOnOffInteractionInfo.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); + readOnOffInteractionInfo.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); + readOnOffInteractionInfo.put( + "readOffWaitTimeAttribute", readOnOffOffWaitTimeAttributeInteractionInfo); + Map readOnOffStartUpOnOffCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffStartUpOnOffAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readStartUpOnOffAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffStartUpOnOffCommandParams); + readOnOffInteractionInfo.put( + "readStartUpOnOffAttribute", readOnOffStartUpOnOffAttributeInteractionInfo); + Map readOnOffAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OnOffCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOnOffClusterAttributeListAttributeCallback(), - readOnOffAttributeListCommandParams - ); - readOnOffInteractionInfo.put("readAttributeListAttribute", readOnOffAttributeListAttributeInteractionInfo); - Map readOnOffFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readOnOffAttributeListCommandParams); + readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.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 - ); - readOnOffInteractionInfo.put("readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("onOff", readOnOffInteractionInfo); - Map readOnOffSwitchConfigurationInteractionInfo = new LinkedHashMap<>(); - Map readOnOffSwitchConfigurationSwitchTypeCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readSwitchTypeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationSwitchTypeCommandParams - ); - readOnOffSwitchConfigurationInteractionInfo.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 - ); - readOnOffSwitchConfigurationInteractionInfo.put("readSwitchActionsAttribute", readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); - Map readOnOffSwitchConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), - readOnOffSwitchConfigurationAttributeListCommandParams - ); - readOnOffSwitchConfigurationInteractionInfo.put("readAttributeListAttribute", readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); - Map readOnOffSwitchConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OnOffSwitchConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOnOffSwitchConfigurationClusterRevisionCommandParams - ); - readOnOffSwitchConfigurationInteractionInfo.put("readClusterRevisionAttribute", readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo); - Map readOperationalCredentialsInteractionInfo = 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 - ); - readOperationalCredentialsInteractionInfo.put("readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); - Map readOperationalCredentialsFabricsListCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsFabricsListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readFabricsListAttribute( - ( ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterFabricsListAttributeCallback(), - readOperationalCredentialsFabricsListCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeInteractionInfo); - Map readOperationalCredentialsSupportedFabricsCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readSupportedFabricsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsSupportedFabricsCommandParams - ); - readOperationalCredentialsInteractionInfo.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 - ); - readOperationalCredentialsInteractionInfo.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 - ); - readOperationalCredentialsInteractionInfo.put("readTrustedRootCertificatesAttribute", readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); - Map readOperationalCredentialsCurrentFabricIndexCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readCurrentFabricIndexAttribute( - ( ChipClusters.OperationalCredentialsCluster.CurrentFabricIndexAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsCurrentFabricIndexCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readCurrentFabricIndexAttribute", readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); - Map readOperationalCredentialsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), - readOperationalCredentialsAttributeListCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readAttributeListAttribute", readOperationalCredentialsAttributeListAttributeInteractionInfo); - Map readOperationalCredentialsClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.OperationalCredentialsCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readOperationalCredentialsClusterRevisionCommandParams - ); - readOperationalCredentialsInteractionInfo.put("readClusterRevisionAttribute", readOperationalCredentialsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("operationalCredentials", readOperationalCredentialsInteractionInfo); - Map readPowerSourceInteractionInfo = new LinkedHashMap<>(); - Map readPowerSourceStatusCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceStatusCommandParams - ); - readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.put("readOrderAttribute", readPowerSourceOrderAttributeInteractionInfo); - Map readPowerSourceDescriptionCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceDescriptionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readDescriptionAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readOnOffFeatureMapCommandParams); + readOnOffInteractionInfo.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); + readOnOffInteractionInfo.put( + "readClusterRevisionAttribute", readOnOffClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOff", readOnOffInteractionInfo); + Map readOnOffSwitchConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map readOnOffSwitchConfigurationSwitchTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationSwitchTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readSwitchTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationSwitchTypeCommandParams); + readOnOffSwitchConfigurationInteractionInfo.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); + readOnOffSwitchConfigurationInteractionInfo.put( + "readSwitchActionsAttribute", + readOnOffSwitchConfigurationSwitchActionsAttributeInteractionInfo); + Map readOnOffSwitchConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OnOffSwitchConfigurationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOnOffSwitchConfigurationClusterAttributeListAttributeCallback(), + readOnOffSwitchConfigurationAttributeListCommandParams); + readOnOffSwitchConfigurationInteractionInfo.put( + "readAttributeListAttribute", + readOnOffSwitchConfigurationAttributeListAttributeInteractionInfo); + Map readOnOffSwitchConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OnOffSwitchConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOnOffSwitchConfigurationClusterRevisionCommandParams); + readOnOffSwitchConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readOnOffSwitchConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("onOffSwitchConfiguration", readOnOffSwitchConfigurationInteractionInfo); + Map readOperationalCredentialsInteractionInfo = 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); + readOperationalCredentialsInteractionInfo.put( + "readNOCsAttribute", readOperationalCredentialsNOCsAttributeInteractionInfo); + Map readOperationalCredentialsFabricsListCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsFabricsListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readFabricsListAttribute( + (ChipClusters.OperationalCredentialsCluster.FabricsListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterFabricsListAttributeCallback(), + readOperationalCredentialsFabricsListCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readFabricsListAttribute", readOperationalCredentialsFabricsListAttributeInteractionInfo); + Map readOperationalCredentialsSupportedFabricsCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsSupportedFabricsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readSupportedFabricsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsSupportedFabricsCommandParams); + readOperationalCredentialsInteractionInfo.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); + readOperationalCredentialsInteractionInfo.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); + readOperationalCredentialsInteractionInfo.put( + "readTrustedRootCertificatesAttribute", + readOperationalCredentialsTrustedRootCertificatesAttributeInteractionInfo); + Map readOperationalCredentialsCurrentFabricIndexCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readCurrentFabricIndexAttribute( + (ChipClusters.OperationalCredentialsCluster + .CurrentFabricIndexAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsCurrentFabricIndexCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readCurrentFabricIndexAttribute", + readOperationalCredentialsCurrentFabricIndexAttributeInteractionInfo); + Map readOperationalCredentialsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.OperationalCredentialsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedOperationalCredentialsClusterAttributeListAttributeCallback(), + readOperationalCredentialsAttributeListCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readAttributeListAttribute", + readOperationalCredentialsAttributeListAttributeInteractionInfo); + Map readOperationalCredentialsClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readOperationalCredentialsClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.OperationalCredentialsCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readOperationalCredentialsClusterRevisionCommandParams); + readOperationalCredentialsInteractionInfo.put( + "readClusterRevisionAttribute", + readOperationalCredentialsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("operationalCredentials", readOperationalCredentialsInteractionInfo); + Map readPowerSourceInteractionInfo = new LinkedHashMap<>(); + Map readPowerSourceStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceStatusCommandParams); + readPowerSourceInteractionInfo.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); + readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.put("readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); - Map readPowerSourceBatteryVoltageCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryVoltageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryVoltageAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPowerSourceDescriptionCommandParams); + readPowerSourceInteractionInfo.put( + "readDescriptionAttribute", readPowerSourceDescriptionAttributeInteractionInfo); + Map readPowerSourceBatteryVoltageCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryVoltageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryVoltageAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatteryVoltageCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeInteractionInfo); - Map readPowerSourceBatteryPercentRemainingCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryPercentRemainingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryPercentRemainingAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryPercentRemainingCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryPercentRemainingAttribute", readPowerSourceBatteryPercentRemainingAttributeInteractionInfo); - Map readPowerSourceBatteryTimeRemainingCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryTimeRemainingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryTimeRemainingAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPowerSourceBatteryVoltageCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryVoltageAttribute", readPowerSourceBatteryVoltageAttributeInteractionInfo); + Map readPowerSourceBatteryPercentRemainingCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryPercentRemainingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryPercentRemainingAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryPercentRemainingCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryPercentRemainingAttribute", + readPowerSourceBatteryPercentRemainingAttributeInteractionInfo); + Map readPowerSourceBatteryTimeRemainingCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryTimeRemainingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryTimeRemainingAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPowerSourceBatteryTimeRemainingCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryTimeRemainingAttribute", readPowerSourceBatteryTimeRemainingAttributeInteractionInfo); - Map readPowerSourceBatteryChargeLevelCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryChargeLevelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryChargeLevelAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryChargeLevelCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryChargeLevelAttribute", readPowerSourceBatteryChargeLevelAttributeInteractionInfo); - Map readPowerSourceActiveBatteryFaultsCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceActiveBatteryFaultsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readActiveBatteryFaultsAttribute( - ( ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback(), - readPowerSourceActiveBatteryFaultsCommandParams - ); - readPowerSourceInteractionInfo.put("readActiveBatteryFaultsAttribute", readPowerSourceActiveBatteryFaultsAttributeInteractionInfo); - Map readPowerSourceBatteryChargeStateCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceBatteryChargeStateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readBatteryChargeStateAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceBatteryChargeStateCommandParams - ); - readPowerSourceInteractionInfo.put("readBatteryChargeStateAttribute", readPowerSourceBatteryChargeStateAttributeInteractionInfo); - Map readPowerSourceAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PowerSourceCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), - readPowerSourceAttributeListCommandParams - ); - readPowerSourceInteractionInfo.put("readAttributeListAttribute", readPowerSourceAttributeListAttributeInteractionInfo); - Map readPowerSourceFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPowerSourceBatteryTimeRemainingCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryTimeRemainingAttribute", + readPowerSourceBatteryTimeRemainingAttributeInteractionInfo); + Map readPowerSourceBatteryChargeLevelCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryChargeLevelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryChargeLevelAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryChargeLevelCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryChargeLevelAttribute", + readPowerSourceBatteryChargeLevelAttributeInteractionInfo); + Map readPowerSourceActiveBatteryFaultsCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceActiveBatteryFaultsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readActiveBatteryFaultsAttribute( + (ChipClusters.PowerSourceCluster.ActiveBatteryFaultsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceClusterActiveBatteryFaultsAttributeCallback(), + readPowerSourceActiveBatteryFaultsCommandParams); + readPowerSourceInteractionInfo.put( + "readActiveBatteryFaultsAttribute", + readPowerSourceActiveBatteryFaultsAttributeInteractionInfo); + Map readPowerSourceBatteryChargeStateCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceBatteryChargeStateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readBatteryChargeStateAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceBatteryChargeStateCommandParams); + readPowerSourceInteractionInfo.put( + "readBatteryChargeStateAttribute", + readPowerSourceBatteryChargeStateAttributeInteractionInfo); + Map readPowerSourceAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PowerSourceCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedPowerSourceClusterAttributeListAttributeCallback(), + readPowerSourceAttributeListCommandParams); + readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.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 - ); - readPowerSourceInteractionInfo.put("readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("powerSource", readPowerSourceInteractionInfo); - Map readPowerSourceConfigurationInteractionInfo = 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 - ); - readPowerSourceConfigurationInteractionInfo.put("readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); - Map readPowerSourceConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), - readPowerSourceConfigurationAttributeListCommandParams - ); - readPowerSourceConfigurationInteractionInfo.put("readAttributeListAttribute", readPowerSourceConfigurationAttributeListAttributeInteractionInfo); - Map readPowerSourceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PowerSourceConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPowerSourceConfigurationClusterRevisionCommandParams - ); - readPowerSourceConfigurationInteractionInfo.put("readClusterRevisionAttribute", readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo); - Map readPressureMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readPressureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMeasuredValueCommandParams - ); - readPressureMeasurementInteractionInfo.put("readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMinMeasuredValueCommandParams - ); - readPressureMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementMaxMeasuredValueCommandParams - ); - readPressureMeasurementInteractionInfo.put("readMaxMeasuredValueAttribute", readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); - Map readPressureMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), - readPressureMeasurementAttributeListCommandParams - ); - readPressureMeasurementInteractionInfo.put("readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); - Map readPressureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PressureMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPressureMeasurementClusterRevisionCommandParams - ); - readPressureMeasurementInteractionInfo.put("readClusterRevisionAttribute", readPressureMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("pressureMeasurement", readPressureMeasurementInteractionInfo); - Map readPumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); - Map readPumpConfigurationAndControlMaxPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxPressureAttribute", readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxFlowAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxFlowCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstPressureAttribute", readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxConstPressureAttribute", readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinCompPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinCompPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinCompPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinCompPressureAttribute", readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxCompPressureCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxCompPressureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxCompPressureCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxCompPressureAttribute", readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstSpeedAttribute", readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxConstSpeedAttribute", readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstFlowAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstFlowCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstFlowAttribute", readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstFlowCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstFlowAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstFlowCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMaxConstFlowAttribute", readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); - Map readPumpConfigurationAndControlMinConstTempCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMinConstTempAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMinConstTempCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readMinConstTempAttribute", readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); - Map readPumpConfigurationAndControlMaxConstTempCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readMaxConstTempAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlMaxConstTempCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.put("readEffectiveControlModeAttribute", readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlCapacityCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readCapacityAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlCapacityCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); - Map readPumpConfigurationAndControlSpeedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readSpeedAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlSpeedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); - Map readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeRunningHoursAttribute( - ( ChipClusters.PumpConfigurationAndControlCluster.LifetimeRunningHoursAttributeCallback - ) callback - ); - }, + readPowerSourceFeatureMapCommandParams); + readPowerSourceInteractionInfo.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); + readPowerSourceInteractionInfo.put( + "readClusterRevisionAttribute", readPowerSourceClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("powerSource", readPowerSourceInteractionInfo); + Map readPowerSourceConfigurationInteractionInfo = + 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); + readPowerSourceConfigurationInteractionInfo.put( + "readSourcesAttribute", readPowerSourceConfigurationSourcesAttributeInteractionInfo); + Map readPowerSourceConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PowerSourceConfigurationCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPowerSourceConfigurationClusterAttributeListAttributeCallback(), + readPowerSourceConfigurationAttributeListCommandParams); + readPowerSourceConfigurationInteractionInfo.put( + "readAttributeListAttribute", + readPowerSourceConfigurationAttributeListAttributeInteractionInfo); + Map readPowerSourceConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PowerSourceConfigurationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPowerSourceConfigurationClusterRevisionCommandParams); + readPowerSourceConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readPowerSourceConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("powerSourceConfiguration", readPowerSourceConfigurationInteractionInfo); + Map readPressureMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readPressureMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMeasuredValueCommandParams); + readPressureMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", readPressureMeasurementMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMinMeasuredValueCommandParams); + readPressureMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readPressureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementMaxMeasuredValueCommandParams); + readPressureMeasurementInteractionInfo.put( + "readMaxMeasuredValueAttribute", + readPressureMeasurementMaxMeasuredValueAttributeInteractionInfo); + Map readPressureMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PressureMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPressureMeasurementClusterAttributeListAttributeCallback(), + readPressureMeasurementAttributeListCommandParams); + readPressureMeasurementInteractionInfo.put( + "readAttributeListAttribute", readPressureMeasurementAttributeListAttributeInteractionInfo); + Map readPressureMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readPressureMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PressureMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPressureMeasurementClusterRevisionCommandParams); + readPressureMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readPressureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("pressureMeasurement", readPressureMeasurementInteractionInfo); + Map readPumpConfigurationAndControlInteractionInfo = + new LinkedHashMap<>(); + Map readPumpConfigurationAndControlMaxPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxPressureAttribute", + readPumpConfigurationAndControlMaxPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxSpeedAttribute", readPumpConfigurationAndControlMaxSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxFlowCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxFlowAttribute", readPumpConfigurationAndControlMaxFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstPressureAttribute", + readPumpConfigurationAndControlMinConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxConstPressureAttribute", + readPumpConfigurationAndControlMaxConstPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinCompPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinCompPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinCompPressureAttribute", + readPumpConfigurationAndControlMinCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxCompPressureCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxCompPressureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxCompPressureCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxCompPressureAttribute", + readPumpConfigurationAndControlMaxCompPressureAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstSpeedAttribute", + readPumpConfigurationAndControlMinConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxConstSpeedAttribute", + readPumpConfigurationAndControlMaxConstSpeedAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstFlowCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstFlowAttribute", + readPumpConfigurationAndControlMinConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstFlowCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstFlowAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstFlowCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMaxConstFlowAttribute", + readPumpConfigurationAndControlMaxConstFlowAttributeInteractionInfo); + Map readPumpConfigurationAndControlMinConstTempCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMinConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMinConstTempCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readMinConstTempAttribute", + readPumpConfigurationAndControlMinConstTempAttributeInteractionInfo); + Map readPumpConfigurationAndControlMaxConstTempCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlMaxConstTempAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readMaxConstTempAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlMaxConstTempCommandParams); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.put( + "readEffectiveControlModeAttribute", + readPumpConfigurationAndControlEffectiveControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlCapacityCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlCapacityAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readCapacityAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlCapacityCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readCapacityAttribute", readPumpConfigurationAndControlCapacityAttributeInteractionInfo); + Map readPumpConfigurationAndControlSpeedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlSpeedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readSpeedAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlSpeedCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readSpeedAttribute", readPumpConfigurationAndControlSpeedAttributeInteractionInfo); + Map + readPumpConfigurationAndControlLifetimeRunningHoursCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readLifetimeRunningHoursAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .LifetimeRunningHoursAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlLifetimeRunningHoursCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readLifetimeRunningHoursAttribute", readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); - Map readPumpConfigurationAndControlPowerCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readPowerAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPumpConfigurationAndControlLifetimeRunningHoursCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readLifetimeRunningHoursAttribute", + readPumpConfigurationAndControlLifetimeRunningHoursAttributeInteractionInfo); + Map readPumpConfigurationAndControlPowerCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlPowerAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readPowerAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlPowerCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); - Map readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readLifetimeEnergyConsumedAttribute( - ( ChipClusters.PumpConfigurationAndControlCluster.LifetimeEnergyConsumedAttributeCallback - ) callback - ); - }, + readPumpConfigurationAndControlPowerCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readPowerAttribute", readPumpConfigurationAndControlPowerAttributeInteractionInfo); + Map + readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlLifetimeEnergyConsumedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readLifetimeEnergyConsumedAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .LifetimeEnergyConsumedAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.put("readControlModeAttribute", readPumpConfigurationAndControlControlModeAttributeInteractionInfo); - Map readPumpConfigurationAndControlAlarmMaskCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAlarmMaskAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readPumpConfigurationAndControlAlarmMaskCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo); - Map readPumpConfigurationAndControlAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readAttributeListAttribute( - ( ChipClusters.PumpConfigurationAndControlCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), - readPumpConfigurationAndControlAttributeListCommandParams - ); - readPumpConfigurationAndControlInteractionInfo.put("readAttributeListAttribute", readPumpConfigurationAndControlAttributeListAttributeInteractionInfo); - Map readPumpConfigurationAndControlFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readPumpConfigurationAndControlFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.PumpConfigurationAndControlCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readPumpConfigurationAndControlLifetimeEnergyConsumedCommandParams); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.put( + "readControlModeAttribute", + readPumpConfigurationAndControlControlModeAttributeInteractionInfo); + Map readPumpConfigurationAndControlAlarmMaskCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readAlarmMaskAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readPumpConfigurationAndControlAlarmMaskCommandParams); + readPumpConfigurationAndControlInteractionInfo.put( + "readAlarmMaskAttribute", readPumpConfigurationAndControlAlarmMaskAttributeInteractionInfo); + Map readPumpConfigurationAndControlAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readPumpConfigurationAndControlAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.PumpConfigurationAndControlCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.PumpConfigurationAndControlCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedPumpConfigurationAndControlClusterAttributeListAttributeCallback(), + readPumpConfigurationAndControlAttributeListCommandParams); + readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.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 - ); - readPumpConfigurationAndControlInteractionInfo.put("readClusterRevisionAttribute", readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo); - Map readRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readRelativeHumidityMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMeasuredValueCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readMeasuredValueAttribute", readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMinMeasuredValueCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementMaxMeasuredValueCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.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 - ); - readRelativeHumidityMeasurementInteractionInfo.put("readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); - Map readRelativeHumidityMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.RelativeHumidityMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), - readRelativeHumidityMeasurementAttributeListCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readAttributeListAttribute", readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); - Map readRelativeHumidityMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.RelativeHumidityMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readRelativeHumidityMeasurementClusterRevisionCommandParams - ); - readRelativeHumidityMeasurementInteractionInfo.put("readClusterRevisionAttribute", readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo); - Map readScenesInteractionInfo = new LinkedHashMap<>(); - Map readScenesSceneCountCommandParams = new LinkedHashMap(); - InteractionInfo readScenesSceneCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readSceneCountAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesSceneCountCommandParams - ); - readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.put("readCurrentGroupAttribute", readScenesCurrentGroupAttributeInteractionInfo); - Map readScenesSceneValidCommandParams = new LinkedHashMap(); - InteractionInfo readScenesSceneValidAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readSceneValidAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readPumpConfigurationAndControlFeatureMapCommandParams); + readPumpConfigurationAndControlInteractionInfo.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); + readPumpConfigurationAndControlInteractionInfo.put( + "readClusterRevisionAttribute", + readPumpConfigurationAndControlClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "pumpConfigurationAndControl", readPumpConfigurationAndControlInteractionInfo); + Map readRelativeHumidityMeasurementInteractionInfo = + new LinkedHashMap<>(); + Map readRelativeHumidityMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMeasuredValueCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", + readRelativeHumidityMeasurementMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMinMeasuredValueCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readRelativeHumidityMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readRelativeHumidityMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementMaxMeasuredValueCommandParams); + readRelativeHumidityMeasurementInteractionInfo.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); + readRelativeHumidityMeasurementInteractionInfo.put( + "readToleranceAttribute", readRelativeHumidityMeasurementToleranceAttributeInteractionInfo); + Map readRelativeHumidityMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.RelativeHumidityMeasurementCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedRelativeHumidityMeasurementClusterAttributeListAttributeCallback(), + readRelativeHumidityMeasurementAttributeListCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readRelativeHumidityMeasurementAttributeListAttributeInteractionInfo); + Map readRelativeHumidityMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.RelativeHumidityMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readRelativeHumidityMeasurementClusterRevisionCommandParams); + readRelativeHumidityMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readRelativeHumidityMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "relativeHumidityMeasurement", readRelativeHumidityMeasurementInteractionInfo); + Map readScenesInteractionInfo = new LinkedHashMap<>(); + Map readScenesSceneCountCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesSceneCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readSceneCountAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesSceneCountCommandParams); + readScenesInteractionInfo.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); + readScenesInteractionInfo.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); + readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.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 - ); - readScenesInteractionInfo.put("readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); - Map readScenesAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readScenesAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ScenesCluster.AttributeListAttributeCallback - ) callback - ); - }, + readScenesSceneValidCommandParams); + readScenesInteractionInfo.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); + readScenesInteractionInfo.put( + "readNameSupportAttribute", readScenesNameSupportAttributeInteractionInfo); + Map readScenesAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ScenesCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedScenesClusterAttributeListAttributeCallback(), - readScenesAttributeListCommandParams - ); - readScenesInteractionInfo.put("readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); - Map readScenesClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ScenesCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readScenesClusterRevisionCommandParams - ); - readScenesInteractionInfo.put("readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("scenes", readScenesInteractionInfo); - Map readSoftwareDiagnosticsInteractionInfo = 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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readThreadMetricsAttribute", readSoftwareDiagnosticsThreadMetricsAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapFreeCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapFreeAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readScenesAttributeListCommandParams); + readScenesInteractionInfo.put( + "readAttributeListAttribute", readScenesAttributeListAttributeInteractionInfo); + Map readScenesClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readScenesClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ScenesCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readScenesClusterRevisionCommandParams); + readScenesInteractionInfo.put( + "readClusterRevisionAttribute", readScenesClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("scenes", readScenesInteractionInfo); + Map readSoftwareDiagnosticsInteractionInfo = 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); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readCurrentHeapFreeAttribute", readSoftwareDiagnosticsCurrentHeapFreeAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapUsedCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapUsedAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSoftwareDiagnosticsCurrentHeapFreeCommandParams); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readCurrentHeapUsedAttribute", readSoftwareDiagnosticsCurrentHeapUsedAttributeInteractionInfo); - Map readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readCurrentHeapHighWatermarkAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSoftwareDiagnosticsCurrentHeapUsedCommandParams); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readCurrentHeapHighWatermarkAttribute", readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); - Map readSoftwareDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), - readSoftwareDiagnosticsAttributeListCommandParams - ); - readSoftwareDiagnosticsInteractionInfo.put("readAttributeListAttribute", readSoftwareDiagnosticsAttributeListAttributeInteractionInfo); - Map readSoftwareDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readSoftwareDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SoftwareDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSoftwareDiagnosticsCurrentHeapHighWatermarkCommandParams); + readSoftwareDiagnosticsInteractionInfo.put( + "readCurrentHeapHighWatermarkAttribute", + readSoftwareDiagnosticsCurrentHeapHighWatermarkAttributeInteractionInfo); + Map readSoftwareDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readSoftwareDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SoftwareDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.SoftwareDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedSoftwareDiagnosticsClusterAttributeListAttributeCallback(), + readSoftwareDiagnosticsAttributeListCommandParams); + readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.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 - ); - readSoftwareDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo); - Map readSwitchInteractionInfo = new LinkedHashMap<>(); - Map readSwitchNumberOfPositionsCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readNumberOfPositionsAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readSwitchNumberOfPositionsCommandParams - ); - readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.put("readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); - Map readSwitchAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readAttributeListAttribute( - ( ChipClusters.SwitchCluster.AttributeListAttributeCallback - ) callback - ); - }, + readSoftwareDiagnosticsFeatureMapCommandParams); + readSoftwareDiagnosticsInteractionInfo.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); + readSoftwareDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readSoftwareDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("softwareDiagnostics", readSoftwareDiagnosticsInteractionInfo); + Map readSwitchInteractionInfo = new LinkedHashMap<>(); + Map readSwitchNumberOfPositionsCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchNumberOfPositionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readNumberOfPositionsAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readSwitchNumberOfPositionsCommandParams); + readSwitchInteractionInfo.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); + readSwitchInteractionInfo.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); + readSwitchInteractionInfo.put( + "readMultiPressMaxAttribute", readSwitchMultiPressMaxAttributeInteractionInfo); + Map readSwitchAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readSwitchAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.SwitchCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.SwitchCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedSwitchClusterAttributeListAttributeCallback(), - readSwitchAttributeListCommandParams - ); - readSwitchInteractionInfo.put("readAttributeListAttribute", readSwitchAttributeListAttributeInteractionInfo); - Map readSwitchFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readSwitchFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.SwitchCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readSwitchAttributeListCommandParams); + readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.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 - ); - readSwitchInteractionInfo.put("readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("switch", readSwitchInteractionInfo); - Map readTargetNavigatorInteractionInfo = new LinkedHashMap<>(); - Map readTargetNavigatorTargetNavigatorListCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorTargetNavigatorListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readTargetNavigatorListAttribute( - ( ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback(), - readTargetNavigatorTargetNavigatorListCommandParams - ); - readTargetNavigatorInteractionInfo.put("readTargetNavigatorListAttribute", readTargetNavigatorTargetNavigatorListAttributeInteractionInfo); - Map readTargetNavigatorCurrentNavigatorTargetCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readCurrentNavigatorTargetAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorCurrentNavigatorTargetCommandParams - ); - readTargetNavigatorInteractionInfo.put("readCurrentNavigatorTargetAttribute", readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo); - Map readTargetNavigatorAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readAttributeListAttribute( - ( ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), - readTargetNavigatorAttributeListCommandParams - ); - readTargetNavigatorInteractionInfo.put("readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); - Map readTargetNavigatorClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TargetNavigatorCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTargetNavigatorClusterRevisionCommandParams - ); - readTargetNavigatorInteractionInfo.put("readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("targetNavigator", readTargetNavigatorInteractionInfo); - Map readTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); - Map readTemperatureMeasurementMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMeasuredValueCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readMeasuredValueAttribute", readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMinMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMinMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMinMeasuredValueCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readMinMeasuredValueAttribute", readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); - Map readTemperatureMeasurementMaxMeasuredValueCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readMaxMeasuredValueAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementMaxMeasuredValueCommandParams - ); - readTemperatureMeasurementInteractionInfo.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 - ); - readTemperatureMeasurementInteractionInfo.put("readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); - Map readTemperatureMeasurementAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readAttributeListAttribute( - ( ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), - readTemperatureMeasurementAttributeListCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readAttributeListAttribute", readTemperatureMeasurementAttributeListAttributeInteractionInfo); - Map readTemperatureMeasurementClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TemperatureMeasurementCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTemperatureMeasurementClusterRevisionCommandParams - ); - readTemperatureMeasurementInteractionInfo.put("readClusterRevisionAttribute", readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo); - Map readTestClusterInteractionInfo = new LinkedHashMap<>(); - Map readTestClusterBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readSwitchFeatureMapCommandParams); + readSwitchInteractionInfo.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); + readSwitchInteractionInfo.put( + "readClusterRevisionAttribute", readSwitchClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("switch", readSwitchInteractionInfo); + Map readTargetNavigatorInteractionInfo = new LinkedHashMap<>(); + Map readTargetNavigatorTargetNavigatorListCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorTargetNavigatorListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readTargetNavigatorListAttribute( + (ChipClusters.TargetNavigatorCluster.TargetNavigatorListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTargetNavigatorClusterTargetNavigatorListAttributeCallback(), + readTargetNavigatorTargetNavigatorListCommandParams); + readTargetNavigatorInteractionInfo.put( + "readTargetNavigatorListAttribute", + readTargetNavigatorTargetNavigatorListAttributeInteractionInfo); + Map readTargetNavigatorCurrentNavigatorTargetCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readCurrentNavigatorTargetAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorCurrentNavigatorTargetCommandParams); + readTargetNavigatorInteractionInfo.put( + "readCurrentNavigatorTargetAttribute", + readTargetNavigatorCurrentNavigatorTargetAttributeInteractionInfo); + Map readTargetNavigatorAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TargetNavigatorCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTargetNavigatorClusterAttributeListAttributeCallback(), + readTargetNavigatorAttributeListCommandParams); + readTargetNavigatorInteractionInfo.put( + "readAttributeListAttribute", readTargetNavigatorAttributeListAttributeInteractionInfo); + Map readTargetNavigatorClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTargetNavigatorClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TargetNavigatorCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTargetNavigatorClusterRevisionCommandParams); + readTargetNavigatorInteractionInfo.put( + "readClusterRevisionAttribute", readTargetNavigatorClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("targetNavigator", readTargetNavigatorInteractionInfo); + Map readTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); + Map readTemperatureMeasurementMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMeasuredValueCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readMeasuredValueAttribute", + readTemperatureMeasurementMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMinMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMinMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMinMeasuredValueCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readMinMeasuredValueAttribute", + readTemperatureMeasurementMinMeasuredValueAttributeInteractionInfo); + Map readTemperatureMeasurementMaxMeasuredValueCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementMaxMeasuredValueAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readMaxMeasuredValueAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementMaxMeasuredValueCommandParams); + readTemperatureMeasurementInteractionInfo.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); + readTemperatureMeasurementInteractionInfo.put( + "readToleranceAttribute", readTemperatureMeasurementToleranceAttributeInteractionInfo); + Map readTemperatureMeasurementAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TemperatureMeasurementCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTemperatureMeasurementClusterAttributeListAttributeCallback(), + readTemperatureMeasurementAttributeListCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readAttributeListAttribute", + readTemperatureMeasurementAttributeListAttributeInteractionInfo); + Map readTemperatureMeasurementClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTemperatureMeasurementClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TemperatureMeasurementCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTemperatureMeasurementClusterRevisionCommandParams); + readTemperatureMeasurementInteractionInfo.put( + "readClusterRevisionAttribute", + readTemperatureMeasurementClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("temperatureMeasurement", readTemperatureMeasurementInteractionInfo); + Map readTestClusterInteractionInfo = new LinkedHashMap<>(); + Map readTestClusterBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readBooleanAttribute", readTestClusterBooleanAttributeInteractionInfo); - Map readTestClusterBitmap8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap8Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterBitmap8CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap8Attribute", readTestClusterBitmap8AttributeInteractionInfo); - Map readTestClusterBitmap16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap16Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterBitmap16CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap16Attribute", readTestClusterBitmap16AttributeInteractionInfo); - Map readTestClusterBitmap32CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap32Attribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readBooleanAttribute", readTestClusterBooleanAttributeInteractionInfo); + Map readTestClusterBitmap8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap8Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterBitmap8CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap8Attribute", readTestClusterBitmap8AttributeInteractionInfo); + Map readTestClusterBitmap16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap16Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterBitmap16CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap16Attribute", readTestClusterBitmap16AttributeInteractionInfo); + Map readTestClusterBitmap32CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap32Attribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterBitmap32CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap32Attribute", readTestClusterBitmap32AttributeInteractionInfo); - Map readTestClusterBitmap64CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readBitmap64Attribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterBitmap32CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap32Attribute", readTestClusterBitmap32AttributeInteractionInfo); + Map readTestClusterBitmap64CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readBitmap64Attribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterBitmap64CommandParams - ); - readTestClusterInteractionInfo.put("readBitmap64Attribute", readTestClusterBitmap64AttributeInteractionInfo); - Map readTestClusterInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt8uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readInt8uAttribute", readTestClusterInt8uAttributeInteractionInfo); - Map readTestClusterInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt16uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); - Map readTestClusterInt24uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt24uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterBitmap64CommandParams); + readTestClusterInteractionInfo.put( + "readBitmap64Attribute", readTestClusterBitmap64AttributeInteractionInfo); + Map readTestClusterInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt8uAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readInt8uAttribute", readTestClusterInt8uAttributeInteractionInfo); + Map readTestClusterInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt16uAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readInt16uAttribute", readTestClusterInt16uAttributeInteractionInfo); + Map readTestClusterInt24uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt24uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt24uCommandParams - ); - readTestClusterInteractionInfo.put("readInt24uAttribute", readTestClusterInt24uAttributeInteractionInfo); - Map readTestClusterInt32uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt32uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt24uCommandParams); + readTestClusterInteractionInfo.put( + "readInt24uAttribute", readTestClusterInt24uAttributeInteractionInfo); + Map readTestClusterInt32uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt32uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt32uCommandParams - ); - readTestClusterInteractionInfo.put("readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); - Map readTestClusterInt40uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt40uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt32uCommandParams); + readTestClusterInteractionInfo.put( + "readInt32uAttribute", readTestClusterInt32uAttributeInteractionInfo); + Map readTestClusterInt40uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt40uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt40uCommandParams - ); - readTestClusterInteractionInfo.put("readInt40uAttribute", readTestClusterInt40uAttributeInteractionInfo); - Map readTestClusterInt48uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt48uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt40uCommandParams); + readTestClusterInteractionInfo.put( + "readInt40uAttribute", readTestClusterInt40uAttributeInteractionInfo); + Map readTestClusterInt48uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt48uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt48uCommandParams - ); - readTestClusterInteractionInfo.put("readInt48uAttribute", readTestClusterInt48uAttributeInteractionInfo); - Map readTestClusterInt56uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt56uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt48uCommandParams); + readTestClusterInteractionInfo.put( + "readInt48uAttribute", readTestClusterInt48uAttributeInteractionInfo); + Map readTestClusterInt56uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt56uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt56uCommandParams - ); - readTestClusterInteractionInfo.put("readInt56uAttribute", readTestClusterInt56uAttributeInteractionInfo); - Map readTestClusterInt64uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt64uAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt56uCommandParams); + readTestClusterInteractionInfo.put( + "readInt56uAttribute", readTestClusterInt56uAttributeInteractionInfo); + Map readTestClusterInt64uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt64uAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt64uCommandParams - ); - readTestClusterInteractionInfo.put("readInt64uAttribute", readTestClusterInt64uAttributeInteractionInfo); - Map readTestClusterInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt8sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readInt8sAttribute", readTestClusterInt8sAttributeInteractionInfo); - Map readTestClusterInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt16sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); - Map readTestClusterInt24sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt24sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt64uCommandParams); + readTestClusterInteractionInfo.put( + "readInt64uAttribute", readTestClusterInt64uAttributeInteractionInfo); + Map readTestClusterInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt8sAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readInt8sAttribute", readTestClusterInt8sAttributeInteractionInfo); + Map readTestClusterInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt16sAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readInt16sAttribute", readTestClusterInt16sAttributeInteractionInfo); + Map readTestClusterInt24sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt24sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt24sCommandParams - ); - readTestClusterInteractionInfo.put("readInt24sAttribute", readTestClusterInt24sAttributeInteractionInfo); - Map readTestClusterInt32sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt32sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt24sCommandParams); + readTestClusterInteractionInfo.put( + "readInt24sAttribute", readTestClusterInt24sAttributeInteractionInfo); + Map readTestClusterInt32sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt32sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt32sCommandParams - ); - readTestClusterInteractionInfo.put("readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); - Map readTestClusterInt40sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt40sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt32sCommandParams); + readTestClusterInteractionInfo.put( + "readInt32sAttribute", readTestClusterInt32sAttributeInteractionInfo); + Map readTestClusterInt40sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt40sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt40sCommandParams - ); - readTestClusterInteractionInfo.put("readInt40sAttribute", readTestClusterInt40sAttributeInteractionInfo); - Map readTestClusterInt48sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt48sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt40sCommandParams); + readTestClusterInteractionInfo.put( + "readInt40sAttribute", readTestClusterInt40sAttributeInteractionInfo); + Map readTestClusterInt48sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt48sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt48sCommandParams - ); - readTestClusterInteractionInfo.put("readInt48sAttribute", readTestClusterInt48sAttributeInteractionInfo); - Map readTestClusterInt56sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt56sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt48sCommandParams); + readTestClusterInteractionInfo.put( + "readInt48sAttribute", readTestClusterInt48sAttributeInteractionInfo); + Map readTestClusterInt56sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt56sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt56sCommandParams - ); - readTestClusterInteractionInfo.put("readInt56sAttribute", readTestClusterInt56sAttributeInteractionInfo); - Map readTestClusterInt64sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readInt64sAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterInt56sCommandParams); + readTestClusterInteractionInfo.put( + "readInt56sAttribute", readTestClusterInt56sAttributeInteractionInfo); + Map readTestClusterInt64sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readInt64sAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterInt64sCommandParams - ); - readTestClusterInteractionInfo.put("readInt64sAttribute", readTestClusterInt64sAttributeInteractionInfo); - Map readTestClusterEnum8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEnum8Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnum8CommandParams - ); - readTestClusterInteractionInfo.put("readEnum8Attribute", readTestClusterEnum8AttributeInteractionInfo); - Map readTestClusterEnum16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEnum16Attribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnum16CommandParams - ); - readTestClusterInteractionInfo.put("readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); - Map readTestClusterFloatSingleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readFloatSingleAttribute( - ( - ChipClusters.FloatAttributeCallback -) callback - ); - }, + readTestClusterInt64sCommandParams); + readTestClusterInteractionInfo.put( + "readInt64sAttribute", readTestClusterInt64sAttributeInteractionInfo); + Map readTestClusterEnum8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEnum8Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnum8CommandParams); + readTestClusterInteractionInfo.put( + "readEnum8Attribute", readTestClusterEnum8AttributeInteractionInfo); + Map readTestClusterEnum16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEnum16Attribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnum16CommandParams); + readTestClusterInteractionInfo.put( + "readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); + Map readTestClusterFloatSingleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readFloatSingleAttribute((ChipClusters.FloatAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readTestClusterFloatSingleCommandParams - ); - readTestClusterInteractionInfo.put("readFloatSingleAttribute", readTestClusterFloatSingleAttributeInteractionInfo); - Map readTestClusterFloatDoubleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readFloatDoubleAttribute( - ( - ChipClusters.DoubleAttributeCallback -) callback - ); - }, + readTestClusterFloatSingleCommandParams); + readTestClusterInteractionInfo.put( + "readFloatSingleAttribute", readTestClusterFloatSingleAttributeInteractionInfo); + Map readTestClusterFloatDoubleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readFloatDoubleAttribute((ChipClusters.DoubleAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readTestClusterFloatDoubleCommandParams - ); - readTestClusterInteractionInfo.put("readFloatDoubleAttribute", readTestClusterFloatDoubleAttributeInteractionInfo); - Map readTestClusterOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readOctetStringAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readTestClusterFloatDoubleCommandParams); + readTestClusterInteractionInfo.put( + "readFloatDoubleAttribute", readTestClusterFloatDoubleAttributeInteractionInfo); + Map readTestClusterOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readOctetStringAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readOctetStringAttribute", readTestClusterOctetStringAttributeInteractionInfo); - Map readTestClusterListInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListInt8uAttribute( - ( ChipClusters.TestClusterCluster.ListInt8uAttributeCallback - ) callback - ); - }, + readTestClusterOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readOctetStringAttribute", readTestClusterOctetStringAttributeInteractionInfo); + Map readTestClusterListInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListInt8uAttribute( + (ChipClusters.TestClusterCluster.ListInt8uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedTestClusterClusterListInt8uAttributeCallback(), - readTestClusterListInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readListInt8uAttribute", readTestClusterListInt8uAttributeInteractionInfo); - Map readTestClusterListOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListOctetStringAttribute( - ( ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListOctetStringAttributeCallback(), - readTestClusterListOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readListOctetStringAttribute", readTestClusterListOctetStringAttributeInteractionInfo); - Map readTestClusterListStructOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListStructOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListStructOctetStringAttribute( - ( ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListStructOctetStringAttributeCallback(), - readTestClusterListStructOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readListStructOctetStringAttribute", readTestClusterListStructOctetStringAttributeInteractionInfo); - Map readTestClusterLongOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readLongOctetStringAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readTestClusterListInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readListInt8uAttribute", readTestClusterListInt8uAttributeInteractionInfo); + Map readTestClusterListOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListOctetStringAttribute( + (ChipClusters.TestClusterCluster.ListOctetStringAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListOctetStringAttributeCallback(), + readTestClusterListOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readListOctetStringAttribute", readTestClusterListOctetStringAttributeInteractionInfo); + Map readTestClusterListStructOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListStructOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListStructOctetStringAttribute( + (ChipClusters.TestClusterCluster.ListStructOctetStringAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListStructOctetStringAttributeCallback(), + readTestClusterListStructOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readListStructOctetStringAttribute", + readTestClusterListStructOctetStringAttributeInteractionInfo); + Map readTestClusterLongOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readLongOctetStringAttribute( + (ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterLongOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeInteractionInfo); - Map readTestClusterCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readCharStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readTestClusterLongOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readLongOctetStringAttribute", readTestClusterLongOctetStringAttributeInteractionInfo); + Map readTestClusterCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterCharStringCommandParams - ); - readTestClusterInteractionInfo.put("readCharStringAttribute", readTestClusterCharStringAttributeInteractionInfo); - Map readTestClusterLongCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterLongCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readLongCharStringAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readTestClusterCharStringCommandParams); + readTestClusterInteractionInfo.put( + "readCharStringAttribute", readTestClusterCharStringAttributeInteractionInfo); + Map readTestClusterLongCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterLongCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readLongCharStringAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterLongCharStringCommandParams - ); - readTestClusterInteractionInfo.put("readLongCharStringAttribute", readTestClusterLongCharStringAttributeInteractionInfo); - Map readTestClusterEpochUsCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEpochUsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEpochUsAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterLongCharStringCommandParams); + readTestClusterInteractionInfo.put( + "readLongCharStringAttribute", readTestClusterLongCharStringAttributeInteractionInfo); + Map readTestClusterEpochUsCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEpochUsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEpochUsAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterEpochUsCommandParams - ); - readTestClusterInteractionInfo.put("readEpochUsAttribute", readTestClusterEpochUsAttributeInteractionInfo); - Map readTestClusterEpochSCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEpochSAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEpochSAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readTestClusterEpochUsCommandParams); + readTestClusterInteractionInfo.put( + "readEpochUsAttribute", readTestClusterEpochUsAttributeInteractionInfo); + Map readTestClusterEpochSCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEpochSAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEpochSAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterEpochSCommandParams - ); - readTestClusterInteractionInfo.put("readEpochSAttribute", readTestClusterEpochSAttributeInteractionInfo); - Map readTestClusterVendorIdCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readVendorIdAttribute( - ( ChipClusters.TestClusterCluster.VendorIdAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterVendorIdCommandParams - ); - readTestClusterInteractionInfo.put("readVendorIdAttribute", readTestClusterVendorIdAttributeInteractionInfo); - Map readTestClusterListNullablesAndOptionalsStructCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListNullablesAndOptionalsStructAttribute( - ( ChipClusters.TestClusterCluster.ListNullablesAndOptionalsStructAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback(), - readTestClusterListNullablesAndOptionalsStructCommandParams - ); - readTestClusterInteractionInfo.put("readListNullablesAndOptionalsStructAttribute", readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); - Map readTestClusterEnumAttrCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readEnumAttrAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterEnumAttrCommandParams - ); - readTestClusterInteractionInfo.put("readEnumAttrAttribute", readTestClusterEnumAttrAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt8uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt8uAttribute", readTestClusterRangeRestrictedInt8uAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt8sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt8sAttribute", readTestClusterRangeRestrictedInt8sAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt16uAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt16uAttribute", readTestClusterRangeRestrictedInt16uAttributeInteractionInfo); - Map readTestClusterRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readRangeRestrictedInt16sAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterRangeRestrictedInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readRangeRestrictedInt16sAttribute", readTestClusterRangeRestrictedInt16sAttributeInteractionInfo); - Map readTestClusterListLongOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterListLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readListLongOctetStringAttribute( - ( ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterListLongOctetStringAttributeCallback(), - readTestClusterListLongOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readListLongOctetStringAttribute", readTestClusterListLongOctetStringAttributeInteractionInfo); - Map readTestClusterTimedWriteBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readTimedWriteBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterEpochSCommandParams); + readTestClusterInteractionInfo.put( + "readEpochSAttribute", readTestClusterEpochSAttributeInteractionInfo); + Map readTestClusterVendorIdCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readVendorIdAttribute( + (ChipClusters.TestClusterCluster.VendorIdAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterVendorIdCommandParams); + readTestClusterInteractionInfo.put( + "readVendorIdAttribute", readTestClusterVendorIdAttributeInteractionInfo); + Map readTestClusterListNullablesAndOptionalsStructCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListNullablesAndOptionalsStructAttribute( + (ChipClusters.TestClusterCluster + .ListNullablesAndOptionalsStructAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListNullablesAndOptionalsStructAttributeCallback(), + readTestClusterListNullablesAndOptionalsStructCommandParams); + readTestClusterInteractionInfo.put( + "readListNullablesAndOptionalsStructAttribute", + readTestClusterListNullablesAndOptionalsStructAttributeInteractionInfo); + Map readTestClusterEnumAttrCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readEnumAttrAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterEnumAttrCommandParams); + readTestClusterInteractionInfo.put( + "readEnumAttrAttribute", readTestClusterEnumAttrAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt8uAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt8uAttribute", + readTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt8sAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt8sAttribute", + readTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt16uAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt16uAttribute", + readTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readRangeRestrictedInt16sAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterRangeRestrictedInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readRangeRestrictedInt16sAttribute", + readTestClusterRangeRestrictedInt16sAttributeInteractionInfo); + Map readTestClusterListLongOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterListLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readListLongOctetStringAttribute( + (ChipClusters.TestClusterCluster.ListLongOctetStringAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedTestClusterClusterListLongOctetStringAttributeCallback(), + readTestClusterListLongOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readListLongOctetStringAttribute", + readTestClusterListLongOctetStringAttributeInteractionInfo); + Map readTestClusterTimedWriteBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterTimedWriteBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readTimedWriteBooleanAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterTimedWriteBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readTimedWriteBooleanAttribute", readTestClusterTimedWriteBooleanAttributeInteractionInfo); - Map readTestClusterGeneralErrorBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readGeneralErrorBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterTimedWriteBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readTimedWriteBooleanAttribute", readTestClusterTimedWriteBooleanAttributeInteractionInfo); + Map readTestClusterGeneralErrorBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterGeneralErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readGeneralErrorBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterGeneralErrorBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readGeneralErrorBooleanAttribute", readTestClusterGeneralErrorBooleanAttributeInteractionInfo); - Map readTestClusterClusterErrorBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readClusterErrorBooleanAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterGeneralErrorBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readGeneralErrorBooleanAttribute", + readTestClusterGeneralErrorBooleanAttributeInteractionInfo); + Map readTestClusterClusterErrorBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterClusterErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readClusterErrorBooleanAttribute( + (ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterClusterErrorBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readClusterErrorBooleanAttribute", readTestClusterClusterErrorBooleanAttributeInteractionInfo); - Map readTestClusterUnsupportedCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readUnsupportedAttribute( - ( - ChipClusters.BooleanAttributeCallback -) callback - ); - }, + readTestClusterClusterErrorBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readClusterErrorBooleanAttribute", + readTestClusterClusterErrorBooleanAttributeInteractionInfo); + Map readTestClusterUnsupportedCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterUnsupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readUnsupportedAttribute((ChipClusters.BooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterUnsupportedCommandParams - ); - readTestClusterInteractionInfo.put("readUnsupportedAttribute", readTestClusterUnsupportedAttributeInteractionInfo); - Map readTestClusterNullableBooleanCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBooleanAttribute( - ( ChipClusters.TestClusterCluster.NullableBooleanAttributeCallback - ) callback - ); - }, + readTestClusterUnsupportedCommandParams); + readTestClusterInteractionInfo.put( + "readUnsupportedAttribute", readTestClusterUnsupportedAttributeInteractionInfo); + Map readTestClusterNullableBooleanCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBooleanAttribute( + (ChipClusters.TestClusterCluster.NullableBooleanAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedBooleanAttributeCallback(), - readTestClusterNullableBooleanCommandParams - ); - readTestClusterInteractionInfo.put("readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeInteractionInfo); - Map readTestClusterNullableBitmap8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap8Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap8AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableBitmap8CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeInteractionInfo); - Map readTestClusterNullableBitmap16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap16Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap16AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableBitmap16CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeInteractionInfo); - Map readTestClusterNullableBitmap32CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap32Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap32AttributeCallback - ) callback - ); - }, + readTestClusterNullableBooleanCommandParams); + readTestClusterInteractionInfo.put( + "readNullableBooleanAttribute", readTestClusterNullableBooleanAttributeInteractionInfo); + Map readTestClusterNullableBitmap8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap8Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap8AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableBitmap8CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap8Attribute", readTestClusterNullableBitmap8AttributeInteractionInfo); + Map readTestClusterNullableBitmap16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap16Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap16AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableBitmap16CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap16Attribute", readTestClusterNullableBitmap16AttributeInteractionInfo); + Map readTestClusterNullableBitmap32CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap32Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap32AttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableBitmap32CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeInteractionInfo); - Map readTestClusterNullableBitmap64CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableBitmap64Attribute( - ( ChipClusters.TestClusterCluster.NullableBitmap64AttributeCallback - ) callback - ); - }, + readTestClusterNullableBitmap32CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap32Attribute", readTestClusterNullableBitmap32AttributeInteractionInfo); + Map readTestClusterNullableBitmap64CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableBitmap64Attribute( + (ChipClusters.TestClusterCluster.NullableBitmap64AttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableBitmap64CommandParams - ); - readTestClusterInteractionInfo.put("readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeInteractionInfo); - Map readTestClusterNullableInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt8uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt8uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeInteractionInfo); - Map readTestClusterNullableInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt16uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt16uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); - Map readTestClusterNullableInt24uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt24uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt24uAttributeCallback - ) callback - ); - }, + readTestClusterNullableBitmap64CommandParams); + readTestClusterInteractionInfo.put( + "readNullableBitmap64Attribute", readTestClusterNullableBitmap64AttributeInteractionInfo); + Map readTestClusterNullableInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt8uAttribute( + (ChipClusters.TestClusterCluster.NullableInt8uAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt8uAttribute", readTestClusterNullableInt8uAttributeInteractionInfo); + Map readTestClusterNullableInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt16uAttribute( + (ChipClusters.TestClusterCluster.NullableInt16uAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt16uAttribute", readTestClusterNullableInt16uAttributeInteractionInfo); + Map readTestClusterNullableInt24uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt24uAttribute( + (ChipClusters.TestClusterCluster.NullableInt24uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt24uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt24uAttribute", readTestClusterNullableInt24uAttributeInteractionInfo); - Map readTestClusterNullableInt32uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt32uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt32uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt24uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt24uAttribute", readTestClusterNullableInt24uAttributeInteractionInfo); + Map readTestClusterNullableInt32uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt32uAttribute( + (ChipClusters.TestClusterCluster.NullableInt32uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt32uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); - Map readTestClusterNullableInt40uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt40uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt40uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt32uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt32uAttribute", readTestClusterNullableInt32uAttributeInteractionInfo); + Map readTestClusterNullableInt40uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt40uAttribute( + (ChipClusters.TestClusterCluster.NullableInt40uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt40uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt40uAttribute", readTestClusterNullableInt40uAttributeInteractionInfo); - Map readTestClusterNullableInt48uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt48uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt48uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt40uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt40uAttribute", readTestClusterNullableInt40uAttributeInteractionInfo); + Map readTestClusterNullableInt48uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt48uAttribute( + (ChipClusters.TestClusterCluster.NullableInt48uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt48uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt48uAttribute", readTestClusterNullableInt48uAttributeInteractionInfo); - Map readTestClusterNullableInt56uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt56uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt56uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt48uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt48uAttribute", readTestClusterNullableInt48uAttributeInteractionInfo); + Map readTestClusterNullableInt56uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt56uAttribute( + (ChipClusters.TestClusterCluster.NullableInt56uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt56uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt56uAttribute", readTestClusterNullableInt56uAttributeInteractionInfo); - Map readTestClusterNullableInt64uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt64uAttribute( - ( ChipClusters.TestClusterCluster.NullableInt64uAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt56uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt56uAttribute", readTestClusterNullableInt56uAttributeInteractionInfo); + Map readTestClusterNullableInt64uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt64uAttribute( + (ChipClusters.TestClusterCluster.NullableInt64uAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt64uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeInteractionInfo); - Map readTestClusterNullableInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt8sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt8sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeInteractionInfo); - Map readTestClusterNullableInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt16sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt16sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); - Map readTestClusterNullableInt24sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt24sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt24sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt64uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt64uAttribute", readTestClusterNullableInt64uAttributeInteractionInfo); + Map readTestClusterNullableInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt8sAttribute( + (ChipClusters.TestClusterCluster.NullableInt8sAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt8sAttribute", readTestClusterNullableInt8sAttributeInteractionInfo); + Map readTestClusterNullableInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt16sAttribute( + (ChipClusters.TestClusterCluster.NullableInt16sAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt16sAttribute", readTestClusterNullableInt16sAttributeInteractionInfo); + Map readTestClusterNullableInt24sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt24sAttribute( + (ChipClusters.TestClusterCluster.NullableInt24sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt24sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt24sAttribute", readTestClusterNullableInt24sAttributeInteractionInfo); - Map readTestClusterNullableInt32sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt32sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt32sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt24sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt24sAttribute", readTestClusterNullableInt24sAttributeInteractionInfo); + Map readTestClusterNullableInt32sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt32sAttribute( + (ChipClusters.TestClusterCluster.NullableInt32sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt32sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); - Map readTestClusterNullableInt40sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt40sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt40sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt32sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt32sAttribute", readTestClusterNullableInt32sAttributeInteractionInfo); + Map readTestClusterNullableInt40sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt40sAttribute( + (ChipClusters.TestClusterCluster.NullableInt40sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt40sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt40sAttribute", readTestClusterNullableInt40sAttributeInteractionInfo); - Map readTestClusterNullableInt48sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt48sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt48sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt40sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt40sAttribute", readTestClusterNullableInt40sAttributeInteractionInfo); + Map readTestClusterNullableInt48sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt48sAttribute( + (ChipClusters.TestClusterCluster.NullableInt48sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt48sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt48sAttribute", readTestClusterNullableInt48sAttributeInteractionInfo); - Map readTestClusterNullableInt56sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt56sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt56sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt48sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt48sAttribute", readTestClusterNullableInt48sAttributeInteractionInfo); + Map readTestClusterNullableInt56sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt56sAttribute( + (ChipClusters.TestClusterCluster.NullableInt56sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt56sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt56sAttribute", readTestClusterNullableInt56sAttributeInteractionInfo); - Map readTestClusterNullableInt64sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableInt64sAttribute( - ( ChipClusters.TestClusterCluster.NullableInt64sAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt56sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt56sAttribute", readTestClusterNullableInt56sAttributeInteractionInfo); + Map readTestClusterNullableInt64sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableInt64sAttribute( + (ChipClusters.TestClusterCluster.NullableInt64sAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readTestClusterNullableInt64sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeInteractionInfo); - Map readTestClusterNullableEnum8CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableEnum8Attribute( - ( ChipClusters.TestClusterCluster.NullableEnum8AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnum8CommandParams - ); - readTestClusterInteractionInfo.put("readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeInteractionInfo); - Map readTestClusterNullableEnum16CommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableEnum16Attribute( - ( ChipClusters.TestClusterCluster.NullableEnum16AttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnum16CommandParams - ); - readTestClusterInteractionInfo.put("readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); - Map readTestClusterNullableFloatSingleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableFloatSingleAttribute( - ( ChipClusters.TestClusterCluster.NullableFloatSingleAttributeCallback - ) callback - ); - }, + readTestClusterNullableInt64sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableInt64sAttribute", readTestClusterNullableInt64sAttributeInteractionInfo); + Map readTestClusterNullableEnum8CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableEnum8Attribute( + (ChipClusters.TestClusterCluster.NullableEnum8AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnum8CommandParams); + readTestClusterInteractionInfo.put( + "readNullableEnum8Attribute", readTestClusterNullableEnum8AttributeInteractionInfo); + Map readTestClusterNullableEnum16CommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableEnum16Attribute( + (ChipClusters.TestClusterCluster.NullableEnum16AttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnum16CommandParams); + readTestClusterInteractionInfo.put( + "readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); + Map readTestClusterNullableFloatSingleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableFloatSingleAttribute( + (ChipClusters.TestClusterCluster.NullableFloatSingleAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), - readTestClusterNullableFloatSingleCommandParams - ); - readTestClusterInteractionInfo.put("readNullableFloatSingleAttribute", readTestClusterNullableFloatSingleAttributeInteractionInfo); - Map readTestClusterNullableFloatDoubleCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableFloatDoubleAttribute( - ( ChipClusters.TestClusterCluster.NullableFloatDoubleAttributeCallback - ) callback - ); - }, + readTestClusterNullableFloatSingleCommandParams); + readTestClusterInteractionInfo.put( + "readNullableFloatSingleAttribute", + readTestClusterNullableFloatSingleAttributeInteractionInfo); + Map readTestClusterNullableFloatDoubleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableFloatDoubleAttribute( + (ChipClusters.TestClusterCluster.NullableFloatDoubleAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), - readTestClusterNullableFloatDoubleCommandParams - ); - readTestClusterInteractionInfo.put("readNullableFloatDoubleAttribute", readTestClusterNullableFloatDoubleAttributeInteractionInfo); - Map readTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableOctetStringAttribute( - ( ChipClusters.TestClusterCluster.NullableOctetStringAttributeCallback - ) callback - ); - }, + readTestClusterNullableFloatDoubleCommandParams); + readTestClusterInteractionInfo.put( + "readNullableFloatDoubleAttribute", + readTestClusterNullableFloatDoubleAttributeInteractionInfo); + Map readTestClusterNullableOctetStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableOctetStringAttribute( + (ChipClusters.TestClusterCluster.NullableOctetStringAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readTestClusterNullableOctetStringCommandParams - ); - readTestClusterInteractionInfo.put("readNullableOctetStringAttribute", readTestClusterNullableOctetStringAttributeInteractionInfo); - Map readTestClusterNullableCharStringCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableCharStringAttribute( - ( ChipClusters.TestClusterCluster.NullableCharStringAttributeCallback - ) callback - ); - }, + readTestClusterNullableOctetStringCommandParams); + readTestClusterInteractionInfo.put( + "readNullableOctetStringAttribute", + readTestClusterNullableOctetStringAttributeInteractionInfo); + Map readTestClusterNullableCharStringCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableCharStringAttribute( + (ChipClusters.TestClusterCluster.NullableCharStringAttributeCallback) + callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readTestClusterNullableCharStringCommandParams - ); - readTestClusterInteractionInfo.put("readNullableCharStringAttribute", readTestClusterNullableCharStringAttributeInteractionInfo); - Map readTestClusterNullableEnumAttrCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableEnumAttrAttribute( - ( ChipClusters.TestClusterCluster.NullableEnumAttrAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableEnumAttrCommandParams - ); - readTestClusterInteractionInfo.put("readNullableEnumAttrAttribute", readTestClusterNullableEnumAttrAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt8uAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt8uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt8uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt8uAttribute", readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt8sAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt8sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt8sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt8sAttribute", readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt16uAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt16uAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt16uCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt16uAttribute", readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map readTestClusterNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readNullableRangeRestrictedInt16sAttribute( - ( ChipClusters.TestClusterCluster.NullableRangeRestrictedInt16sAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterNullableRangeRestrictedInt16sCommandParams - ); - readTestClusterInteractionInfo.put("readNullableRangeRestrictedInt16sAttribute", readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); - Map readTestClusterAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readAttributeListAttribute( - ( ChipClusters.TestClusterCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedTestClusterClusterAttributeListAttributeCallback(), - readTestClusterAttributeListCommandParams - ); - readTestClusterInteractionInfo.put("readAttributeListAttribute", readTestClusterAttributeListAttributeInteractionInfo); - Map readTestClusterClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTestClusterClusterRevisionCommandParams - ); - readTestClusterInteractionInfo.put("readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("testCluster", readTestClusterInteractionInfo); - Map readThermostatInteractionInfo = new LinkedHashMap<>(); - Map readThermostatLocalTemperatureCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readLocalTemperatureAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatLocalTemperatureCommandParams - ); - readThermostatInteractionInfo.put("readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); - Map readThermostatAbsMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAbsMinHeatSetpointLimitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatAbsMinHeatSetpointLimitCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readAbsMaxCoolSetpointLimitAttribute", readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); - Map readThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readOccupiedCoolingSetpointAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatOccupiedCoolingSetpointCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readOccupiedHeatingSetpointAttribute", readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); - Map readThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readMinHeatSetpointLimitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatMinHeatSetpointLimitCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readMinSetpointDeadBandAttribute", readThermostatMinSetpointDeadBandAttributeInteractionInfo); - Map readThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readControlSequenceOfOperationAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatControlSequenceOfOperationCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); - Map readThermostatStartOfWeekCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readStartOfWeekAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatStartOfWeekCommandParams - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readNumberOfDailyTransitionsAttribute", readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); - Map readThermostatAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ThermostatCluster.AttributeListAttributeCallback - ) callback - ); - }, + readTestClusterNullableCharStringCommandParams); + readTestClusterInteractionInfo.put( + "readNullableCharStringAttribute", + readTestClusterNullableCharStringAttributeInteractionInfo); + Map readTestClusterNullableEnumAttrCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableEnumAttrAttribute( + (ChipClusters.TestClusterCluster.NullableEnumAttrAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableEnumAttrCommandParams); + readTestClusterInteractionInfo.put( + "readNullableEnumAttrAttribute", readTestClusterNullableEnumAttrAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt8uAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt8uAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt8uAttribute", + readTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt8sAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt8sAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt8sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt8sAttribute", + readTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt16uAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt16uAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16uCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt16uAttribute", + readTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map readTestClusterNullableRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableRangeRestrictedInt16sAttribute( + (ChipClusters.TestClusterCluster + .NullableRangeRestrictedInt16sAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterNullableRangeRestrictedInt16sCommandParams); + readTestClusterInteractionInfo.put( + "readNullableRangeRestrictedInt16sAttribute", + readTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); + Map readTestClusterAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.TestClusterCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping.DelegatedTestClusterClusterAttributeListAttributeCallback(), + readTestClusterAttributeListCommandParams); + readTestClusterInteractionInfo.put( + "readAttributeListAttribute", readTestClusterAttributeListAttributeInteractionInfo); + Map readTestClusterClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTestClusterClusterRevisionCommandParams); + readTestClusterInteractionInfo.put( + "readClusterRevisionAttribute", readTestClusterClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("testCluster", readTestClusterInteractionInfo); + Map readThermostatInteractionInfo = new LinkedHashMap<>(); + Map readThermostatLocalTemperatureCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatLocalTemperatureAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readLocalTemperatureAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatLocalTemperatureCommandParams); + readThermostatInteractionInfo.put( + "readLocalTemperatureAttribute", readThermostatLocalTemperatureAttributeInteractionInfo); + Map readThermostatAbsMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAbsMinHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAbsMinHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatAbsMinHeatSetpointLimitCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readAbsMaxCoolSetpointLimitAttribute", + readThermostatAbsMaxCoolSetpointLimitAttributeInteractionInfo); + Map readThermostatOccupiedCoolingSetpointCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatOccupiedCoolingSetpointAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readOccupiedCoolingSetpointAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatOccupiedCoolingSetpointCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readOccupiedHeatingSetpointAttribute", + readThermostatOccupiedHeatingSetpointAttributeInteractionInfo); + Map readThermostatMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatMinHeatSetpointLimitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readMinHeatSetpointLimitAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatMinHeatSetpointLimitCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readMinSetpointDeadBandAttribute", + readThermostatMinSetpointDeadBandAttributeInteractionInfo); + Map readThermostatControlSequenceOfOperationCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatControlSequenceOfOperationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readControlSequenceOfOperationAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatControlSequenceOfOperationCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readSystemModeAttribute", readThermostatSystemModeAttributeInteractionInfo); + Map readThermostatStartOfWeekCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatStartOfWeekAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readStartOfWeekAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatStartOfWeekCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readNumberOfDailyTransitionsAttribute", + readThermostatNumberOfDailyTransitionsAttributeInteractionInfo); + Map readThermostatAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThermostatCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedThermostatClusterAttributeListAttributeCallback(), - readThermostatAttributeListCommandParams - ); - readThermostatInteractionInfo.put("readAttributeListAttribute", readThermostatAttributeListAttributeInteractionInfo); - Map readThermostatFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThermostatAttributeListCommandParams); + readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.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 - ); - readThermostatInteractionInfo.put("readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("thermostat", readThermostatInteractionInfo); - Map readThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); - Map readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readTemperatureDisplayModeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams - ); - readThermostatUserInterfaceConfigurationInteractionInfo.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 - ); - readThermostatUserInterfaceConfigurationInteractionInfo.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 - ); - readThermostatUserInterfaceConfigurationInteractionInfo.put("readScheduleProgrammingVisibilityAttribute", readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ThermostatUserInterfaceConfigurationCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), - readThermostatUserInterfaceConfigurationAttributeListCommandParams - ); - readThermostatUserInterfaceConfigurationInteractionInfo.put("readAttributeListAttribute", readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); - Map readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThermostatUserInterfaceConfigurationClusterRevisionCommandParams - ); - readThermostatUserInterfaceConfigurationInteractionInfo.put("readClusterRevisionAttribute", readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("thermostatUserInterfaceConfiguration", readThermostatUserInterfaceConfigurationInteractionInfo); - Map readThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - Map readThreadNetworkDiagnosticsChannelCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsChannelCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRoutingRoleAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsRoutingRoleCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRoutingRoleAttribute", readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNetworkNameCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNetworkNameAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readThermostatFeatureMapCommandParams); + readThermostatInteractionInfo.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); + readThermostatInteractionInfo.put( + "readClusterRevisionAttribute", readThermostatClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("thermostat", readThermostatInteractionInfo); + Map readThermostatUserInterfaceConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = + new LinkedHashMap(); + InteractionInfo + readThermostatUserInterfaceConfigurationTemperatureDisplayModeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readTemperatureDisplayModeAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams); + readThermostatUserInterfaceConfigurationInteractionInfo.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); + readThermostatUserInterfaceConfigurationInteractionInfo.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); + readThermostatUserInterfaceConfigurationInteractionInfo.put( + "readScheduleProgrammingVisibilityAttribute", + readThermostatUserInterfaceConfigurationScheduleProgrammingVisibilityAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThermostatUserInterfaceConfigurationCluster + .AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThermostatUserInterfaceConfigurationClusterAttributeListAttributeCallback(), + readThermostatUserInterfaceConfigurationAttributeListCommandParams); + readThermostatUserInterfaceConfigurationInteractionInfo.put( + "readAttributeListAttribute", + readThermostatUserInterfaceConfigurationAttributeListAttributeInteractionInfo); + Map + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo + readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThermostatUserInterfaceConfigurationCluster) cluster) + .readClusterRevisionAttribute( + (ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThermostatUserInterfaceConfigurationClusterRevisionCommandParams); + readThermostatUserInterfaceConfigurationInteractionInfo.put( + "readClusterRevisionAttribute", + readThermostatUserInterfaceConfigurationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put( + "thermostatUserInterfaceConfiguration", + readThermostatUserInterfaceConfigurationInteractionInfo); + Map readThreadNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + Map readThreadNetworkDiagnosticsChannelCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readChannelAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsChannelCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readChannelAttribute", readThreadNetworkDiagnosticsChannelAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRoutingRoleCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRoutingRoleAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsRoutingRoleCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRoutingRoleAttribute", + readThreadNetworkDiagnosticsRoutingRoleAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNetworkNameCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readNetworkNameAttribute((ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readThreadNetworkDiagnosticsNetworkNameCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readNetworkNameAttribute", readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPanIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPanIdAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsPanIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readExtendedPanIdAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsNetworkNameCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readNetworkNameAttribute", + readThreadNetworkDiagnosticsNetworkNameAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPanIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPanIdAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsPanIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readPanIdAttribute", readThreadNetworkDiagnosticsPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsExtendedPanIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readExtendedPanIdAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsExtendedPanIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readExtendedPanIdAttribute", readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readMeshLocalPrefixAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsExtendedPanIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readExtendedPanIdAttribute", + readThreadNetworkDiagnosticsExtendedPanIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readMeshLocalPrefixAttribute( + (ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readMeshLocalPrefixAttribute", readThreadNetworkDiagnosticsMeshLocalPrefixAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsMeshLocalPrefixCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsNeighborTableListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readNeighborTableListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.NeighborTableListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback(), - readThreadNetworkDiagnosticsNeighborTableListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readNeighborTableListAttribute", readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRouteTableListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRouteTableListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback(), - readThreadNetworkDiagnosticsRouteTableListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRouteTableListAttribute", readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPartitionIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPartitionIdAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsOverrunCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readOverrunCountAttribute", + readThreadNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsNeighborTableListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readNeighborTableListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .NeighborTableListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterNeighborTableListAttributeCallback(), + readThreadNetworkDiagnosticsNeighborTableListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readNeighborTableListAttribute", + readThreadNetworkDiagnosticsNeighborTableListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRouteTableListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRouteTableListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.RouteTableListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterRouteTableListAttributeCallback(), + readThreadNetworkDiagnosticsRouteTableListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRouteTableListAttribute", + readThreadNetworkDiagnosticsRouteTableListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPartitionIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPartitionIdAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsPartitionIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readPartitionIdAttribute", readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsWeightingCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readWeightingAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsWeightingCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDataVersionCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDataVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsDataVersionCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readDataVersionAttribute", readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readStableDataVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsStableDataVersionCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readStableDataVersionAttribute", readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readLeaderRouterIdAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readThreadNetworkDiagnosticsLeaderRouterIdCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readParentChangeCountAttribute", readThreadNetworkDiagnosticsParentChangeCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxTotalCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxTotalCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsPartitionIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readPartitionIdAttribute", + readThreadNetworkDiagnosticsPartitionIdAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsWeightingCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readWeightingAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsWeightingCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readWeightingAttribute", readThreadNetworkDiagnosticsWeightingAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDataVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsDataVersionCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readDataVersionAttribute", + readThreadNetworkDiagnosticsDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsStableDataVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readStableDataVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsStableDataVersionCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readStableDataVersionAttribute", + readThreadNetworkDiagnosticsStableDataVersionAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsLeaderRouterIdCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsLeaderRouterIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readLeaderRouterIdAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readThreadNetworkDiagnosticsLeaderRouterIdCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxTotalCountAttribute", readThreadNetworkDiagnosticsTxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxUnicastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxUnicastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxTotalCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxUnicastCountAttribute", readThreadNetworkDiagnosticsTxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBroadcastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBroadcastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxUnicastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxBroadcastCountAttribute", readThreadNetworkDiagnosticsTxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxAckRequestedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxBroadcastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxAckRequestedCountAttribute", readThreadNetworkDiagnosticsTxAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxAckedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxAckedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxAckRequestedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxAckedCountAttribute", readThreadNetworkDiagnosticsTxAckedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxNoAckRequestedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxAckedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxNoAckRequestedCountAttribute", readThreadNetworkDiagnosticsTxNoAckRequestedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDataCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxNoAckRequestedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxDataCountAttribute", readThreadNetworkDiagnosticsTxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDataPollCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDataPollCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxDataCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxDataPollCountAttribute", readThreadNetworkDiagnosticsTxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBeaconCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBeaconCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxDataPollCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxBeaconCountAttribute", readThreadNetworkDiagnosticsTxBeaconCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxBeaconRequestCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxBeaconCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsTxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxOtherCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxBeaconRequestCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxOtherCountAttribute", readThreadNetworkDiagnosticsTxOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxRetryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxRetryCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxOtherCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxRetryCountAttribute", readThreadNetworkDiagnosticsTxRetryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxDirectMaxRetryExpiryCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxRetryCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxIndirectMaxRetryExpiryCountAttribute", + readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrCcaCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxDirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxDirectMaxRetryExpiryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxIndirectMaxRetryExpiryCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxErrCcaCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxErrCcaCountAttribute", + readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrAbortCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxIndirectMaxRetryExpiryCountAttribute", readThreadNetworkDiagnosticsTxIndirectMaxRetryExpiryCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrCcaCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrCcaCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxErrAbortCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxErrAbortCountAttribute", + readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readTxErrBusyChannelCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrCcaCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrCcaCountAttribute", readThreadNetworkDiagnosticsTxErrCcaCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrAbortCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrAbortCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readTxErrBusyChannelCountAttribute", + readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxTotalCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrAbortCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrAbortCountAttribute", readThreadNetworkDiagnosticsTxErrAbortCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readTxErrBusyChannelCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxTotalCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxTotalCountAttribute", + readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxUnicastCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsTxErrBusyChannelCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readTxErrBusyChannelCountAttribute", readThreadNetworkDiagnosticsTxErrBusyChannelCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxTotalCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxTotalCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxUnicastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxUnicastCountAttribute", + readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBroadcastCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxTotalCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxTotalCountAttribute", readThreadNetworkDiagnosticsRxTotalCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxUnicastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxUnicastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxBroadcastCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxBroadcastCountAttribute", + readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDataCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxUnicastCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxUnicastCountAttribute", readThreadNetworkDiagnosticsRxUnicastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBroadcastCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBroadcastCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDataCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDataCountAttribute", + readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDataPollCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBroadcastCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxBroadcastCountAttribute", readThreadNetworkDiagnosticsRxBroadcastCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDataPollCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDataPollCountAttribute", + readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBeaconCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDataCountAttribute", readThreadNetworkDiagnosticsRxDataCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDataPollCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDataPollCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxBeaconCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxBeaconCountAttribute", + readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxBeaconRequestCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDataPollCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDataPollCountAttribute", readThreadNetworkDiagnosticsRxDataPollCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBeaconCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxBeaconRequestCountAttribute", + readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxBeaconCountAttribute", readThreadNetworkDiagnosticsRxBeaconCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxBeaconRequestCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxOtherCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxOtherCountAttribute", + readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxAddressFilteredCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxBeaconRequestCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxBeaconRequestCountAttribute", readThreadNetworkDiagnosticsRxBeaconRequestCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxOtherCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxAddressFilteredCountAttribute", + readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDestAddrFilteredCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxOtherCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxOtherCountAttribute", readThreadNetworkDiagnosticsRxOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxAddressFilteredCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDestAddrFilteredCountAttribute", + readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxDuplicatedCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxAddressFilteredCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxAddressFilteredCountAttribute", readThreadNetworkDiagnosticsRxAddressFilteredCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDestAddrFilteredCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxDuplicatedCountAttribute", + readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrNoFrameCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDestAddrFilteredCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDestAddrFilteredCountAttribute", readThreadNetworkDiagnosticsRxDestAddrFilteredCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxDuplicatedCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrNoFrameCountAttribute", + readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrUnknownNeighborCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxDuplicatedCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxDuplicatedCountAttribute", readThreadNetworkDiagnosticsRxDuplicatedCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrNoFrameCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrUnknownNeighborCountAttribute", + readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrInvalidSrcAddrCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrNoFrameCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrNoFrameCountAttribute", readThreadNetworkDiagnosticsRxErrNoFrameCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrUnknownNeighborCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrInvalidSrcAddrCountAttribute", + readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrSecCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrUnknownNeighborCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrUnknownNeighborCountAttribute", readThreadNetworkDiagnosticsRxErrUnknownNeighborCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrInvalidSrcAddrCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrSecCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrSecCountAttribute", + readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrFcsCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrInvalidSrcAddrCountAttribute", readThreadNetworkDiagnosticsRxErrInvalidSrcAddrCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrSecCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrSecCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrFcsCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrFcsCountAttribute", + readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readRxErrOtherCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrSecCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrSecCountAttribute", readThreadNetworkDiagnosticsRxErrSecCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrFcsCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrFcsCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsRxErrOtherCountCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readRxErrOtherCountAttribute", + readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readActiveTimestampAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrFcsCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrFcsCountAttribute", readThreadNetworkDiagnosticsRxErrFcsCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsRxErrOtherCountCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readRxErrOtherCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsActiveTimestampCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readActiveTimestampAttribute", + readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readPendingTimestampAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsRxErrOtherCountCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readRxErrOtherCountAttribute", readThreadNetworkDiagnosticsRxErrOtherCountAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsActiveTimestampCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveTimestampAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsPendingTimestampCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readPendingTimestampAttribute", + readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsDelayCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readDelayAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsActiveTimestampCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readActiveTimestampAttribute", readThreadNetworkDiagnosticsActiveTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsPendingTimestampCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readPendingTimestampAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsPendingTimestampCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readPendingTimestampAttribute", readThreadNetworkDiagnosticsPendingTimestampAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsDelayCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsDelayAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readDelayAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readThreadNetworkDiagnosticsDelayCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsSecurityPolicyCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readSecurityPolicyAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback(), - readThreadNetworkDiagnosticsSecurityPolicyCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readSecurityPolicyAttribute", readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsChannelMaskCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readChannelMaskAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsDelayCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readDelayAttribute", readThreadNetworkDiagnosticsDelayAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsSecurityPolicyCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readSecurityPolicyAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.SecurityPolicyAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterSecurityPolicyAttributeCallback(), + readThreadNetworkDiagnosticsSecurityPolicyCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readSecurityPolicyAttribute", + readThreadNetworkDiagnosticsSecurityPolicyAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsChannelMaskCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readChannelMaskAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readThreadNetworkDiagnosticsChannelMaskCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readChannelMaskAttribute", readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readOperationalDatasetComponentsAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.OperationalDatasetComponentsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback(), - readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readOperationalDatasetComponentsAttribute", readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readActiveNetworkFaultsListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.ActiveNetworkFaultsListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), - readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readActiveNetworkFaultsListAttribute", readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readThreadNetworkDiagnosticsAttributeListCommandParams - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readAttributeListAttribute", readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readThreadNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readThreadNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsChannelMaskCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readChannelMaskAttribute", + readThreadNetworkDiagnosticsChannelMaskAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams = + new LinkedHashMap(); + InteractionInfo + readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readOperationalDatasetComponentsAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .OperationalDatasetComponentsAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterOperationalDatasetComponentsAttributeCallback(), + readThreadNetworkDiagnosticsOperationalDatasetComponentsCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readOperationalDatasetComponentsAttribute", + readThreadNetworkDiagnosticsOperationalDatasetComponentsAttributeInteractionInfo); + Map + readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readActiveNetworkFaultsListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster + .ActiveNetworkFaultsListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterActiveNetworkFaultsListAttributeCallback(), + readThreadNetworkDiagnosticsActiveNetworkFaultsListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readActiveNetworkFaultsListAttribute", + readThreadNetworkDiagnosticsActiveNetworkFaultsListAttributeInteractionInfo); + Map readThreadNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readThreadNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ThreadNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.ThreadNetworkDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedThreadNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readThreadNetworkDiagnosticsAttributeListCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.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 - ); - readThreadNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo); - Map readTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map readTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readHourFormatAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationHourFormatCommandParams - ); - readTimeFormatLocalizationInteractionInfo.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 - ); - readTimeFormatLocalizationInteractionInfo.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 - ); - readTimeFormatLocalizationInteractionInfo.put("readSupportedCalendarTypesAttribute", readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); - Map readTimeFormatLocalizationClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TimeFormatLocalizationCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readTimeFormatLocalizationClusterRevisionCommandParams - ); - readTimeFormatLocalizationInteractionInfo.put("readClusterRevisionAttribute", readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo); - Map readUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map readUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readTemperatureUnitAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUnitLocalizationTemperatureUnitCommandParams - ); - readUnitLocalizationInteractionInfo.put("readTemperatureUnitAttribute", readUnitLocalizationTemperatureUnitAttributeInteractionInfo); - Map readUnitLocalizationFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UnitLocalizationCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readThreadNetworkDiagnosticsFeatureMapCommandParams); + readThreadNetworkDiagnosticsInteractionInfo.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); + readThreadNetworkDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readThreadNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("threadNetworkDiagnostics", readThreadNetworkDiagnosticsInteractionInfo); + Map readTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); + Map readTimeFormatLocalizationHourFormatCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationHourFormatAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readHourFormatAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationHourFormatCommandParams); + readTimeFormatLocalizationInteractionInfo.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); + readTimeFormatLocalizationInteractionInfo.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); + readTimeFormatLocalizationInteractionInfo.put( + "readSupportedCalendarTypesAttribute", + readTimeFormatLocalizationSupportedCalendarTypesAttributeInteractionInfo); + Map readTimeFormatLocalizationClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TimeFormatLocalizationCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readTimeFormatLocalizationClusterRevisionCommandParams); + readTimeFormatLocalizationInteractionInfo.put( + "readClusterRevisionAttribute", + readTimeFormatLocalizationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("timeFormatLocalization", readTimeFormatLocalizationInteractionInfo); + Map readUnitLocalizationInteractionInfo = new LinkedHashMap<>(); + Map readUnitLocalizationTemperatureUnitCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationTemperatureUnitAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readTemperatureUnitAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUnitLocalizationTemperatureUnitCommandParams); + readUnitLocalizationInteractionInfo.put( + "readTemperatureUnitAttribute", + readUnitLocalizationTemperatureUnitAttributeInteractionInfo); + Map readUnitLocalizationFeatureMapCommandParams = + new LinkedHashMap(); + InteractionInfo readUnitLocalizationFeatureMapAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UnitLocalizationCluster) cluster) + .readFeatureMapAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readUnitLocalizationFeatureMapCommandParams - ); - readUnitLocalizationInteractionInfo.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 - ); - readUnitLocalizationInteractionInfo.put("readClusterRevisionAttribute", readUnitLocalizationClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("unitLocalization", readUnitLocalizationInteractionInfo); - Map readUserLabelInteractionInfo = new LinkedHashMap<>(); - Map readUserLabelLabelListCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelLabelListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readLabelListAttribute( - ( ChipClusters.UserLabelCluster.LabelListAttributeCallback - ) callback - ); - }, + readUnitLocalizationFeatureMapCommandParams); + readUnitLocalizationInteractionInfo.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); + readUnitLocalizationInteractionInfo.put( + "readClusterRevisionAttribute", + readUnitLocalizationClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("unitLocalization", readUnitLocalizationInteractionInfo); + Map readUserLabelInteractionInfo = 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 - ); - readUserLabelInteractionInfo.put("readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); - Map readUserLabelClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.UserLabelCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readUserLabelClusterRevisionCommandParams - ); - readUserLabelInteractionInfo.put("readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("userLabel", readUserLabelInteractionInfo); - Map readWakeOnLanInteractionInfo = new LinkedHashMap<>(); - Map readWakeOnLanWakeOnLanMacAddressCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readWakeOnLanMacAddressAttribute( - ( - ChipClusters.CharStringAttributeCallback -) callback - ); - }, + readUserLabelLabelListCommandParams); + readUserLabelInteractionInfo.put( + "readLabelListAttribute", readUserLabelLabelListAttributeInteractionInfo); + Map readUserLabelClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readUserLabelClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.UserLabelCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readUserLabelClusterRevisionCommandParams); + readUserLabelInteractionInfo.put( + "readClusterRevisionAttribute", readUserLabelClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("userLabel", readUserLabelInteractionInfo); + Map readWakeOnLanInteractionInfo = new LinkedHashMap<>(); + Map readWakeOnLanWakeOnLanMacAddressCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readWakeOnLanMacAddressAttribute( + (ChipClusters.CharStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedCharStringAttributeCallback(), - readWakeOnLanWakeOnLanMacAddressCommandParams - ); - readWakeOnLanInteractionInfo.put("readWakeOnLanMacAddressAttribute", readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo); - Map readWakeOnLanAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readAttributeListAttribute( - ( ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback - ) callback - ); - }, + readWakeOnLanWakeOnLanMacAddressCommandParams); + readWakeOnLanInteractionInfo.put( + "readWakeOnLanMacAddressAttribute", + readWakeOnLanWakeOnLanMacAddressAttributeInteractionInfo); + Map readWakeOnLanAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WakeOnLanCluster.AttributeListAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedWakeOnLanClusterAttributeListAttributeCallback(), - readWakeOnLanAttributeListCommandParams - ); - readWakeOnLanInteractionInfo.put("readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); - Map readWakeOnLanClusterRevisionCommandParams = new LinkedHashMap(); - InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WakeOnLanCluster) cluster).readClusterRevisionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWakeOnLanClusterRevisionCommandParams - ); - readWakeOnLanInteractionInfo.put("readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("wakeOnLan", readWakeOnLanInteractionInfo); - Map readWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - Map readWiFiNetworkDiagnosticsBssidCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBssidAttribute( - ( - ChipClusters.OctetStringAttributeCallback -) callback - ); - }, + readWakeOnLanAttributeListCommandParams); + readWakeOnLanInteractionInfo.put( + "readAttributeListAttribute", readWakeOnLanAttributeListAttributeInteractionInfo); + Map readWakeOnLanClusterRevisionCommandParams = + new LinkedHashMap(); + InteractionInfo readWakeOnLanClusterRevisionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WakeOnLanCluster) cluster) + .readClusterRevisionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWakeOnLanClusterRevisionCommandParams); + readWakeOnLanInteractionInfo.put( + "readClusterRevisionAttribute", readWakeOnLanClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wakeOnLan", readWakeOnLanInteractionInfo); + Map readWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + Map readWiFiNetworkDiagnosticsBssidCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBssidAttribute((ChipClusters.OctetStringAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedOctetStringAttributeCallback(), - readWiFiNetworkDiagnosticsBssidCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readSecurityTypeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsSecurityTypeCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readSecurityTypeAttribute", readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readWiFiVersionAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsWiFiVersionCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readChannelNumberAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsChannelNumberCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readChannelNumberAttribute", readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsRssiCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readRssiAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWiFiNetworkDiagnosticsRssiCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconLostCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsBssidCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readBssidAttribute", readWiFiNetworkDiagnosticsBssidAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsSecurityTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readSecurityTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsSecurityTypeCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readSecurityTypeAttribute", + readWiFiNetworkDiagnosticsSecurityTypeAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsWiFiVersionCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readWiFiVersionAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsWiFiVersionCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readWiFiVersionAttribute", readWiFiNetworkDiagnosticsWiFiVersionAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsChannelNumberCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readChannelNumberAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsChannelNumberCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readChannelNumberAttribute", + readWiFiNetworkDiagnosticsChannelNumberAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsRssiCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readRssiAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWiFiNetworkDiagnosticsRssiCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readRssiAttribute", readWiFiNetworkDiagnosticsRssiAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconLostCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBeaconLostCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconLostCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readBeaconLostCountAttribute", readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readBeaconRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsBeaconLostCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readBeaconLostCountAttribute", + readWiFiNetworkDiagnosticsBeaconLostCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsBeaconRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readBeaconRxCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsBeaconRxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readBeaconRxCountAttribute", readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsBeaconRxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readBeaconRxCountAttribute", + readWiFiNetworkDiagnosticsBeaconRxCountAttributeInteractionInfo); + Map + readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketMulticastRxCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketMulticastRxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketMulticastTxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketMulticastRxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketMulticastRxCountAttribute", + readWiFiNetworkDiagnosticsPacketMulticastRxCountAttributeInteractionInfo); + Map + readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketMulticastTxCountAttribute( + (ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketMulticastTxCountAttribute", readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastRxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketMulticastTxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketMulticastTxCountAttribute", + readWiFiNetworkDiagnosticsPacketMulticastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketUnicastRxCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketUnicastRxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readPacketUnicastTxCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketUnicastRxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketUnicastRxCountAttribute", + readWiFiNetworkDiagnosticsPacketUnicastRxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readPacketUnicastTxCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readPacketUnicastTxCountAttribute", readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readCurrentMaxRateAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsPacketUnicastTxCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readPacketUnicastTxCountAttribute", + readWiFiNetworkDiagnosticsPacketUnicastTxCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readCurrentMaxRateAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readCurrentMaxRateAttribute", readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readOverrunCountAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsCurrentMaxRateCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readCurrentMaxRateAttribute", + readWiFiNetworkDiagnosticsCurrentMaxRateAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsOverrunCountCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readOverrunCountAttribute((ChipClusters.LongAttributeCallback) callback); + }, () -> new ClusterInfoMapping.DelegatedLongAttributeCallback(), - readWiFiNetworkDiagnosticsOverrunCountCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readOverrunCountAttribute", readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readAttributeListAttribute( - ( ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), - readWiFiNetworkDiagnosticsAttributeListCommandParams - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readAttributeListAttribute", readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo); - Map readWiFiNetworkDiagnosticsFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readWiFiNetworkDiagnosticsFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsOverrunCountCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readOverrunCountAttribute", + readWiFiNetworkDiagnosticsOverrunCountAttributeInteractionInfo); + Map readWiFiNetworkDiagnosticsAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWiFiNetworkDiagnosticsAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WiFiNetworkDiagnosticsCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WiFiNetworkDiagnosticsCluster.AttributeListAttributeCallback) + callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWiFiNetworkDiagnosticsClusterAttributeListAttributeCallback(), + readWiFiNetworkDiagnosticsAttributeListCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.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 - ); - readWiFiNetworkDiagnosticsInteractionInfo.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 - ); - readWiFiNetworkDiagnosticsInteractionInfo.put("readClusterRevisionAttribute", readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo); - Map readWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map readWindowCoveringTypeCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTypeAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTypeCommandParams - ); - readWindowCoveringInteractionInfo.put("readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionLiftAttribute", readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionTiltAttribute", readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); - Map readWindowCoveringConfigStatusCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readConfigStatusAttribute( - ( - ChipClusters.IntegerAttributeCallback -) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringConfigStatusCommandParams - ); - readWindowCoveringInteractionInfo.put("readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercentageAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercentageAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercentageCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionLiftPercentageAttribute", readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercentageAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercentageAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercentageCommandParams - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readOperationalStatusAttribute", readWindowCoveringOperationalStatusAttributeInteractionInfo); - Map readWindowCoveringTargetPositionLiftPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionLiftPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.TargetPositionLiftPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTargetPositionLiftPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.put("readTargetPositionLiftPercent100thsAttribute", readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); - Map readWindowCoveringTargetPositionTiltPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readTargetPositionTiltPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.TargetPositionTiltPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringTargetPositionTiltPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionLiftPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionLiftPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionLiftPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.put("readCurrentPositionLiftPercent100thsAttribute", readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); - Map readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readCurrentPositionTiltPercent100thsAttribute( - ( ChipClusters.WindowCoveringCluster.CurrentPositionTiltPercent100thsAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), - readWindowCoveringCurrentPositionTiltPercent100thsCommandParams - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); - Map readWindowCoveringAttributeListCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readAttributeListAttribute( - ( ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback - ) callback - ); - }, - () -> new ClusterInfoMapping.DelegatedWindowCoveringClusterAttributeListAttributeCallback(), - readWindowCoveringAttributeListCommandParams - ); - readWindowCoveringInteractionInfo.put("readAttributeListAttribute", readWindowCoveringAttributeListAttributeInteractionInfo); - Map readWindowCoveringFeatureMapCommandParams = new LinkedHashMap(); - InteractionInfo readWindowCoveringFeatureMapAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.WindowCoveringCluster) cluster).readFeatureMapAttribute( - ( - ChipClusters.LongAttributeCallback -) callback - ); - }, + readWiFiNetworkDiagnosticsFeatureMapCommandParams); + readWiFiNetworkDiagnosticsInteractionInfo.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); + readWiFiNetworkDiagnosticsInteractionInfo.put( + "readClusterRevisionAttribute", + readWiFiNetworkDiagnosticsClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("wiFiNetworkDiagnostics", readWiFiNetworkDiagnosticsInteractionInfo); + Map readWindowCoveringInteractionInfo = new LinkedHashMap<>(); + Map readWindowCoveringTypeCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTypeAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTypeAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTypeCommandParams); + readWindowCoveringInteractionInfo.put( + "readTypeAttribute", readWindowCoveringTypeAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionLiftAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionLiftAttribute", + readWindowCoveringCurrentPositionLiftAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltAttribute( + (ChipClusters.WindowCoveringCluster.CurrentPositionTiltAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionTiltAttribute", + readWindowCoveringCurrentPositionTiltAttributeInteractionInfo); + Map readWindowCoveringConfigStatusCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringConfigStatusAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readConfigStatusAttribute((ChipClusters.IntegerAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringConfigStatusCommandParams); + readWindowCoveringInteractionInfo.put( + "readConfigStatusAttribute", readWindowCoveringConfigStatusAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionLiftPercentageCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftPercentageAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionLiftPercentageAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercentageCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionLiftPercentageAttribute", + readWindowCoveringCurrentPositionLiftPercentageAttributeInteractionInfo); + Map readWindowCoveringCurrentPositionTiltPercentageCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercentageAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltPercentageAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionTiltPercentageAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercentageCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readOperationalStatusAttribute", + readWindowCoveringOperationalStatusAttributeInteractionInfo); + Map + readWindowCoveringTargetPositionLiftPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTargetPositionLiftPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .TargetPositionLiftPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTargetPositionLiftPercent100thsCommandParams); + readWindowCoveringInteractionInfo.put( + "readTargetPositionLiftPercent100thsAttribute", + readWindowCoveringTargetPositionLiftPercent100thsAttributeInteractionInfo); + Map + readWindowCoveringTargetPositionTiltPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringTargetPositionTiltPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readTargetPositionTiltPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .TargetPositionTiltPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringTargetPositionTiltPercent100thsCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readEndProductTypeAttribute", readWindowCoveringEndProductTypeAttributeInteractionInfo); + Map + readWindowCoveringCurrentPositionLiftPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionLiftPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionLiftPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionLiftPercent100thsCommandParams); + readWindowCoveringInteractionInfo.put( + "readCurrentPositionLiftPercent100thsAttribute", + readWindowCoveringCurrentPositionLiftPercent100thsAttributeInteractionInfo); + Map + readWindowCoveringCurrentPositionTiltPercent100thsCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringCurrentPositionTiltPercent100thsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readCurrentPositionTiltPercent100thsAttribute( + (ChipClusters.WindowCoveringCluster + .CurrentPositionTiltPercent100thsAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedIntegerAttributeCallback(), + readWindowCoveringCurrentPositionTiltPercent100thsCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readSafetyStatusAttribute", readWindowCoveringSafetyStatusAttributeInteractionInfo); + Map readWindowCoveringAttributeListCommandParams = + new LinkedHashMap(); + InteractionInfo readWindowCoveringAttributeListAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.WindowCoveringCluster) cluster) + .readAttributeListAttribute( + (ChipClusters.WindowCoveringCluster.AttributeListAttributeCallback) callback); + }, + () -> + new ClusterInfoMapping + .DelegatedWindowCoveringClusterAttributeListAttributeCallback(), + readWindowCoveringAttributeListCommandParams); + readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.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 - ); - readWindowCoveringInteractionInfo.put("readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); - readAttributeMap.put("windowCovering", readWindowCoveringInteractionInfo); - return readAttributeMap; + readWindowCoveringFeatureMapCommandParams); + readWindowCoveringInteractionInfo.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); + readWindowCoveringInteractionInfo.put( + "readClusterRevisionAttribute", readWindowCoveringClusterRevisionAttributeInteractionInfo); + readAttributeMap.put("windowCovering", readWindowCoveringInteractionInfo); + return readAttributeMap; } } diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java index e701c60d01ca31..4ee787dfd94515 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java @@ -29,2292 +29,2466 @@ public class ClusterWriteMapping { public Map> getWriteAttributeMap() { Map> writeAttributeMap = new HashMap<>(); - Map writeAccessControlInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("accessControl", writeAccessControlInteractionInfo); - Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); - Map writeAdministratorCommissioningInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("administratorCommissioning", writeAdministratorCommissioningInteractionInfo); - Map writeApplicationBasicInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("applicationBasic", writeApplicationBasicInteractionInfo); - Map writeApplicationLauncherInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("applicationLauncher", writeApplicationLauncherInteractionInfo); - Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); - Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); - Map writeBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBasicNodeLabelCommandParams = new LinkedHashMap(); - CommandParameterInfo basicnodeLabelCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeBasicNodeLabelCommandParams.put("value",basicnodeLabelCommandParameterInfo); - InteractionInfo writeBasicNodeLabelAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).writeNodeLabelAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicNodeLabelCommandParams - ); - writeBasicInteractionInfo.put("writeNodeLabelAttribute", writeBasicNodeLabelAttributeInteractionInfo); - Map writeBasicLocationCommandParams = new LinkedHashMap(); - CommandParameterInfo basiclocationCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeBasicLocationCommandParams.put("value",basiclocationCommandParameterInfo); - InteractionInfo writeBasicLocationAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).writeLocationAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicLocationCommandParams - ); - writeBasicInteractionInfo.put("writeLocationAttribute", writeBasicLocationAttributeInteractionInfo); - Map writeBasicLocalConfigDisabledCommandParams = new LinkedHashMap(); - CommandParameterInfo basiclocalConfigDisabledCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeBasicLocalConfigDisabledCommandParams.put("value",basiclocalConfigDisabledCommandParameterInfo); - InteractionInfo writeBasicLocalConfigDisabledAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.BasicCluster) cluster).writeLocalConfigDisabledAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeBasicLocalConfigDisabledCommandParams - ); - writeBasicInteractionInfo.put("writeLocalConfigDisabledAttribute", writeBasicLocalConfigDisabledAttributeInteractionInfo); - writeAttributeMap.put("basic", writeBasicInteractionInfo); - Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); - Map writeBinaryInputBasicOutOfServiceCommandParams = new LinkedHashMap(); - CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); - Map writeBindingInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("binding", writeBindingInteractionInfo); - Map writeBooleanStateInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("booleanState", writeBooleanStateInteractionInfo); - Map writeBridgedActionsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("bridgedActions", writeBridgedActionsInteractionInfo); - Map writeBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("bridgedDeviceBasic", writeBridgedDeviceBasicInteractionInfo); - Map writeChannelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("channel", writeChannelInteractionInfo); - Map writeColorControlInteractionInfo = new LinkedHashMap<>(); - Map writeColorControlColorControlOptionsCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlcolorControlOptionsCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeColorControlColorControlOptionsCommandParams.put("value",colorControlcolorControlOptionsCommandParameterInfo); - InteractionInfo writeColorControlColorControlOptionsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.ColorControlCluster) cluster).writeColorControlOptionsAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeColorControlColorControlOptionsCommandParams - ); - writeColorControlInteractionInfo.put("writeColorControlOptionsAttribute", writeColorControlColorControlOptionsAttributeInteractionInfo); - Map writeColorControlWhitePointXCommandParams = new LinkedHashMap(); - CommandParameterInfo colorControlwhitePointXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlwhitePointYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); - Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); - Map writeContentLauncherSupportedStreamingProtocolsCommandParams = new LinkedHashMap(); - CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); - Map writeDescriptorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("descriptor", writeDescriptorInteractionInfo); - Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); - Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); - Map writeDoorLockLanguageCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLocklanguageCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockAutoRelockTimeCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = new CommandParameterInfo("value", 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); - 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 writeDoorLockEnableOneTouchLockingCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockEnablePrivacyModeButtonCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = new CommandParameterInfo("value", 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 writeDoorLockWrongCodeEntryLimitCommandParams = new LinkedHashMap(); - CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); - Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); - Map writeEthernetNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); - Map writeFixedLabelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("fixedLabel", writeFixedLabelInteractionInfo); - Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); - Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeGeneralCommissioningBreadcrumbCommandParams = new LinkedHashMap(); - CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); - Map writeGeneralDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); - Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("groupKeyManagement", writeGroupKeyManagementInteractionInfo); - Map writeGroupsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("groups", writeGroupsInteractionInfo); - Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); - Map writeIdentifyIdentifyTimeCommandParams = new LinkedHashMap(); - CommandParameterInfo identifyidentifyTimeCommandParameterInfo = new CommandParameterInfo("value", 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 writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); - Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); - Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); - Map writeLevelControlOptionsCommandParams = new LinkedHashMap(); - CommandParameterInfo levelControloptionsCommandParameterInfo = new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo levelControlonLevelCommandParameterInfo = new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); - Map writeLocalizationConfigurationInteractionInfo = new LinkedHashMap<>(); - Map writeLocalizationConfigurationActiveLocaleCommandParams = new LinkedHashMap(); - CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = new CommandParameterInfo("value", 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); - Map writeLowPowerInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("lowPower", writeLowPowerInteractionInfo); - Map writeMediaInputInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("mediaInput", writeMediaInputInteractionInfo); - Map writeMediaPlaybackInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("mediaPlayback", writeMediaPlaybackInteractionInfo); - Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); - Map writeModeSelectOnModeCommandParams = new LinkedHashMap(); - CommandParameterInfo modeSelectonModeCommandParameterInfo = new CommandParameterInfo("value", 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 writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); - Map writeNetworkCommissioningInterfaceEnabledCommandParams = new LinkedHashMap(); - CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); - Map writeOtaSoftwareUpdateProviderInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); - Map writeOtaSoftwareUpdateRequestorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); - Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); - Map writeOnOffInteractionInfo = new LinkedHashMap<>(); - Map writeOnOffOnTimeCommandParams = new LinkedHashMap(); - CommandParameterInfo onOffonTimeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = new CommandParameterInfo("value", 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); - 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(); - CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); - Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); - Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); - Map writePowerSourceConfigurationInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); - Map writePressureMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); - Map writePumpConfigurationAndControlInteractionInfo = new LinkedHashMap<>(); - Map writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = new LinkedHashMap(); - CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = new CommandParameterInfo("value", 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); - Map writeRelativeHumidityMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); - Map writeScenesInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("scenes", writeScenesInteractionInfo); - Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); - Map writeSwitchInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("switch", writeSwitchInteractionInfo); - Map writeTargetNavigatorInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("targetNavigator", writeTargetNavigatorInteractionInfo); - Map writeTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("temperatureMeasurement", writeTemperatureMeasurementInteractionInfo); - Map writeTestClusterInteractionInfo = new LinkedHashMap<>(); - Map writeTestClusterBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterBooleanCommandParams.put("value",testClusterbooleanCommandParameterInfo); - InteractionInfo writeTestClusterBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeBooleanAttribute", writeTestClusterBooleanAttributeInteractionInfo); - Map writeTestClusterBitmap8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterBitmap8CommandParams.put("value",testClusterbitmap8CommandParameterInfo); - InteractionInfo writeTestClusterBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap8CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap8Attribute", writeTestClusterBitmap8AttributeInteractionInfo); - Map writeTestClusterBitmap16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterBitmap16CommandParams.put("value",testClusterbitmap16CommandParameterInfo); - InteractionInfo writeTestClusterBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap16CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap16Attribute", writeTestClusterBitmap16AttributeInteractionInfo); - Map writeTestClusterBitmap32CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap32CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterBitmap32CommandParams.put("value",testClusterbitmap32CommandParameterInfo); - InteractionInfo writeTestClusterBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap32Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap32CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap32Attribute", writeTestClusterBitmap32AttributeInteractionInfo); - Map writeTestClusterBitmap64CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterbitmap64CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterBitmap64CommandParams.put("value",testClusterbitmap64CommandParameterInfo); - InteractionInfo writeTestClusterBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeBitmap64Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterBitmap64CommandParams - ); - writeTestClusterInteractionInfo.put("writeBitmap64Attribute", writeTestClusterBitmap64AttributeInteractionInfo); - Map writeTestClusterInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt8uCommandParams.put("value",testClusterint8uCommandParameterInfo); - InteractionInfo writeTestClusterInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt8uAttribute", writeTestClusterInt8uAttributeInteractionInfo); - Map writeTestClusterInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt16uCommandParams.put("value",testClusterint16uCommandParameterInfo); - InteractionInfo writeTestClusterInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt16uAttribute", writeTestClusterInt16uAttributeInteractionInfo); - Map writeTestClusterInt24uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint24uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt24uCommandParams.put("value",testClusterint24uCommandParameterInfo); - InteractionInfo writeTestClusterInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt24uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt24uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt24uAttribute", writeTestClusterInt24uAttributeInteractionInfo); - Map writeTestClusterInt32uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint32uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt32uCommandParams.put("value",testClusterint32uCommandParameterInfo); - InteractionInfo writeTestClusterInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt32uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt32uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt32uAttribute", writeTestClusterInt32uAttributeInteractionInfo); - Map writeTestClusterInt40uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint40uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt40uCommandParams.put("value",testClusterint40uCommandParameterInfo); - InteractionInfo writeTestClusterInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt40uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt40uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt40uAttribute", writeTestClusterInt40uAttributeInteractionInfo); - Map writeTestClusterInt48uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint48uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt48uCommandParams.put("value",testClusterint48uCommandParameterInfo); - InteractionInfo writeTestClusterInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt48uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt48uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt48uAttribute", writeTestClusterInt48uAttributeInteractionInfo); - Map writeTestClusterInt56uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint56uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt56uCommandParams.put("value",testClusterint56uCommandParameterInfo); - InteractionInfo writeTestClusterInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt56uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt56uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt56uAttribute", writeTestClusterInt56uAttributeInteractionInfo); - Map writeTestClusterInt64uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint64uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt64uCommandParams.put("value",testClusterint64uCommandParameterInfo); - InteractionInfo writeTestClusterInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt64uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt64uCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt64uAttribute", writeTestClusterInt64uAttributeInteractionInfo); - Map writeTestClusterInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt8sCommandParams.put("value",testClusterint8sCommandParameterInfo); - InteractionInfo writeTestClusterInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt8sAttribute", writeTestClusterInt8sAttributeInteractionInfo); - Map writeTestClusterInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterInt16sCommandParams.put("value",testClusterint16sCommandParameterInfo); - InteractionInfo writeTestClusterInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt16sAttribute", writeTestClusterInt16sAttributeInteractionInfo); - Map writeTestClusterInt24sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint24sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt24sCommandParams.put("value",testClusterint24sCommandParameterInfo); - InteractionInfo writeTestClusterInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt24sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt24sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt24sAttribute", writeTestClusterInt24sAttributeInteractionInfo); - Map writeTestClusterInt32sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint32sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt32sCommandParams.put("value",testClusterint32sCommandParameterInfo); - InteractionInfo writeTestClusterInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt32sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt32sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt32sAttribute", writeTestClusterInt32sAttributeInteractionInfo); - Map writeTestClusterInt40sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint40sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt40sCommandParams.put("value",testClusterint40sCommandParameterInfo); - InteractionInfo writeTestClusterInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt40sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt40sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt40sAttribute", writeTestClusterInt40sAttributeInteractionInfo); - Map writeTestClusterInt48sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint48sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt48sCommandParams.put("value",testClusterint48sCommandParameterInfo); - InteractionInfo writeTestClusterInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt48sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt48sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt48sAttribute", writeTestClusterInt48sAttributeInteractionInfo); - Map writeTestClusterInt56sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint56sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt56sCommandParams.put("value",testClusterint56sCommandParameterInfo); - InteractionInfo writeTestClusterInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt56sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt56sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt56sAttribute", writeTestClusterInt56sAttributeInteractionInfo); - Map writeTestClusterInt64sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterint64sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterInt64sCommandParams.put("value",testClusterint64sCommandParameterInfo); - InteractionInfo writeTestClusterInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeInt64sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterInt64sCommandParams - ); - writeTestClusterInteractionInfo.put("writeInt64sAttribute", writeTestClusterInt64sAttributeInteractionInfo); - Map writeTestClusterEnum8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterenum8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterEnum8CommandParams.put("value",testClusterenum8CommandParameterInfo); - InteractionInfo writeTestClusterEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEnum8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnum8CommandParams - ); - writeTestClusterInteractionInfo.put("writeEnum8Attribute", writeTestClusterEnum8AttributeInteractionInfo); - Map writeTestClusterEnum16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterenum16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterEnum16CommandParams.put("value",testClusterenum16CommandParameterInfo); - InteractionInfo writeTestClusterEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEnum16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnum16CommandParams - ); - writeTestClusterInteractionInfo.put("writeEnum16Attribute", writeTestClusterEnum16AttributeInteractionInfo); - Map writeTestClusterFloatSingleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterfloatSingleCommandParameterInfo = new CommandParameterInfo("value", Float.class); - writeTestClusterFloatSingleCommandParams.put("value",testClusterfloatSingleCommandParameterInfo); - InteractionInfo writeTestClusterFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeFloatSingleAttribute( - (DefaultClusterCallback) callback, - (Float) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterFloatSingleCommandParams - ); - writeTestClusterInteractionInfo.put("writeFloatSingleAttribute", writeTestClusterFloatSingleAttributeInteractionInfo); - Map writeTestClusterFloatDoubleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterfloatDoubleCommandParameterInfo = new CommandParameterInfo("value", Double.class); - writeTestClusterFloatDoubleCommandParams.put("value",testClusterfloatDoubleCommandParameterInfo); - InteractionInfo writeTestClusterFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeFloatDoubleAttribute( - (DefaultClusterCallback) callback, - (Double) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterFloatDoubleCommandParams - ); - writeTestClusterInteractionInfo.put("writeFloatDoubleAttribute", writeTestClusterFloatDoubleAttributeInteractionInfo); - Map writeTestClusterOctetStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusteroctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); - writeTestClusterOctetStringCommandParams.put("value",testClusteroctetStringCommandParameterInfo); - InteractionInfo writeTestClusterOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterOctetStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeOctetStringAttribute", writeTestClusterOctetStringAttributeInteractionInfo); - Map writeTestClusterLongOctetStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterlongOctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); - writeTestClusterLongOctetStringCommandParams.put("value",testClusterlongOctetStringCommandParameterInfo); - InteractionInfo writeTestClusterLongOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeLongOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterLongOctetStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeLongOctetStringAttribute", writeTestClusterLongOctetStringAttributeInteractionInfo); - Map writeTestClusterCharStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustercharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeTestClusterCharStringCommandParams.put("value",testClustercharStringCommandParameterInfo); - InteractionInfo writeTestClusterCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeCharStringAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterCharStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeCharStringAttribute", writeTestClusterCharStringAttributeInteractionInfo); - Map writeTestClusterLongCharStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterlongCharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeTestClusterLongCharStringCommandParams.put("value",testClusterlongCharStringCommandParameterInfo); - InteractionInfo writeTestClusterLongCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeLongCharStringAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterLongCharStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeLongCharStringAttribute", writeTestClusterLongCharStringAttributeInteractionInfo); - Map writeTestClusterEpochUsCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterepochUsCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterEpochUsCommandParams.put("value",testClusterepochUsCommandParameterInfo); - InteractionInfo writeTestClusterEpochUsAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEpochUsAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEpochUsCommandParams - ); - writeTestClusterInteractionInfo.put("writeEpochUsAttribute", writeTestClusterEpochUsAttributeInteractionInfo); - Map writeTestClusterEpochSCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterepochSCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterEpochSCommandParams.put("value",testClusterepochSCommandParameterInfo); - InteractionInfo writeTestClusterEpochSAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEpochSAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEpochSCommandParams - ); - writeTestClusterInteractionInfo.put("writeEpochSAttribute", writeTestClusterEpochSAttributeInteractionInfo); - Map writeTestClusterVendorIdCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustervendorIdCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterVendorIdCommandParams.put("value",testClustervendorIdCommandParameterInfo); - InteractionInfo writeTestClusterVendorIdAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeVendorIdAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterVendorIdCommandParams - ); - writeTestClusterInteractionInfo.put("writeVendorIdAttribute", writeTestClusterVendorIdAttributeInteractionInfo); - Map writeTestClusterEnumAttrCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterenumAttrCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterEnumAttrCommandParams.put("value",testClusterenumAttrCommandParameterInfo); - InteractionInfo writeTestClusterEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeEnumAttrAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterEnumAttrCommandParams - ); - writeTestClusterInteractionInfo.put("writeEnumAttrAttribute", writeTestClusterEnumAttrAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt8uCommandParams.put("value",testClusterrangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt8uAttribute", writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt8sCommandParams.put("value",testClusterrangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt8sAttribute", writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt16uCommandParams.put("value",testClusterrangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt16uAttribute", writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo); - Map writeTestClusterRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterrangeRestrictedInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterRangeRestrictedInt16sCommandParams.put("value",testClusterrangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterRangeRestrictedInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeRangeRestrictedInt16sAttribute", writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo); - Map writeTestClusterTimedWriteBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustertimedWriteBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterTimedWriteBooleanCommandParams.put("value",testClustertimedWriteBooleanCommandParameterInfo); - InteractionInfo writeTestClusterTimedWriteBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeTimedWriteBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - , 10000 - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterTimedWriteBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeTimedWriteBooleanAttribute", writeTestClusterTimedWriteBooleanAttributeInteractionInfo); - Map writeTestClusterGeneralErrorBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClustergeneralErrorBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterGeneralErrorBooleanCommandParams.put("value",testClustergeneralErrorBooleanCommandParameterInfo); - InteractionInfo writeTestClusterGeneralErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeGeneralErrorBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterGeneralErrorBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeGeneralErrorBooleanAttribute", writeTestClusterGeneralErrorBooleanAttributeInteractionInfo); - Map writeTestClusterClusterErrorBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterclusterErrorBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterClusterErrorBooleanCommandParams.put("value",testClusterclusterErrorBooleanCommandParameterInfo); - InteractionInfo writeTestClusterClusterErrorBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeClusterErrorBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterClusterErrorBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeClusterErrorBooleanAttribute", writeTestClusterClusterErrorBooleanAttributeInteractionInfo); - Map writeTestClusterUnsupportedCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusterunsupportedCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterUnsupportedCommandParams.put("value",testClusterunsupportedCommandParameterInfo); - InteractionInfo writeTestClusterUnsupportedAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeUnsupportedAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterUnsupportedCommandParams - ); - writeTestClusterInteractionInfo.put("writeUnsupportedAttribute", writeTestClusterUnsupportedAttributeInteractionInfo); - Map writeTestClusterNullableBooleanCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBooleanCommandParameterInfo = new CommandParameterInfo("value", Boolean.class); - writeTestClusterNullableBooleanCommandParams.put("value",testClusternullableBooleanCommandParameterInfo); - InteractionInfo writeTestClusterNullableBooleanAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBooleanAttribute( - (DefaultClusterCallback) callback, - (Boolean) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBooleanCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBooleanAttribute", writeTestClusterNullableBooleanAttributeInteractionInfo); - Map writeTestClusterNullableBitmap8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableBitmap8CommandParams.put("value",testClusternullableBitmap8CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap8CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap8Attribute", writeTestClusterNullableBitmap8AttributeInteractionInfo); - Map writeTestClusterNullableBitmap16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableBitmap16CommandParams.put("value",testClusternullableBitmap16CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap16CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap16Attribute", writeTestClusterNullableBitmap16AttributeInteractionInfo); - Map writeTestClusterNullableBitmap32CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap32CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableBitmap32CommandParams.put("value",testClusternullableBitmap32CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap32AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap32Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap32CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap32Attribute", writeTestClusterNullableBitmap32AttributeInteractionInfo); - Map writeTestClusterNullableBitmap64CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableBitmap64CommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableBitmap64CommandParams.put("value",testClusternullableBitmap64CommandParameterInfo); - InteractionInfo writeTestClusterNullableBitmap64AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableBitmap64Attribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableBitmap64CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableBitmap64Attribute", writeTestClusterNullableBitmap64AttributeInteractionInfo); - Map writeTestClusterNullableInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt8uCommandParams.put("value",testClusternullableInt8uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt8uAttribute", writeTestClusterNullableInt8uAttributeInteractionInfo); - Map writeTestClusterNullableInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt16uCommandParams.put("value",testClusternullableInt16uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt16uAttribute", writeTestClusterNullableInt16uAttributeInteractionInfo); - Map writeTestClusterNullableInt24uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt24uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt24uCommandParams.put("value",testClusternullableInt24uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt24uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt24uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt24uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt24uAttribute", writeTestClusterNullableInt24uAttributeInteractionInfo); - Map writeTestClusterNullableInt32uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt32uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt32uCommandParams.put("value",testClusternullableInt32uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt32uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt32uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt32uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt32uAttribute", writeTestClusterNullableInt32uAttributeInteractionInfo); - Map writeTestClusterNullableInt40uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt40uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt40uCommandParams.put("value",testClusternullableInt40uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt40uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt40uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt40uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt40uAttribute", writeTestClusterNullableInt40uAttributeInteractionInfo); - Map writeTestClusterNullableInt48uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt48uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt48uCommandParams.put("value",testClusternullableInt48uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt48uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt48uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt48uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt48uAttribute", writeTestClusterNullableInt48uAttributeInteractionInfo); - Map writeTestClusterNullableInt56uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt56uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt56uCommandParams.put("value",testClusternullableInt56uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt56uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt56uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt56uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt56uAttribute", writeTestClusterNullableInt56uAttributeInteractionInfo); - Map writeTestClusterNullableInt64uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt64uCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt64uCommandParams.put("value",testClusternullableInt64uCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt64uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt64uAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt64uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt64uAttribute", writeTestClusterNullableInt64uAttributeInteractionInfo); - Map writeTestClusterNullableInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt8sCommandParams.put("value",testClusternullableInt8sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt8sAttribute", writeTestClusterNullableInt8sAttributeInteractionInfo); - Map writeTestClusterNullableInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableInt16sCommandParams.put("value",testClusternullableInt16sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt16sAttribute", writeTestClusterNullableInt16sAttributeInteractionInfo); - Map writeTestClusterNullableInt24sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt24sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt24sCommandParams.put("value",testClusternullableInt24sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt24sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt24sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt24sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt24sAttribute", writeTestClusterNullableInt24sAttributeInteractionInfo); - Map writeTestClusterNullableInt32sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt32sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt32sCommandParams.put("value",testClusternullableInt32sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt32sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt32sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt32sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt32sAttribute", writeTestClusterNullableInt32sAttributeInteractionInfo); - Map writeTestClusterNullableInt40sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt40sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt40sCommandParams.put("value",testClusternullableInt40sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt40sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt40sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt40sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt40sAttribute", writeTestClusterNullableInt40sAttributeInteractionInfo); - Map writeTestClusterNullableInt48sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt48sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt48sCommandParams.put("value",testClusternullableInt48sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt48sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt48sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt48sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt48sAttribute", writeTestClusterNullableInt48sAttributeInteractionInfo); - Map writeTestClusterNullableInt56sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt56sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt56sCommandParams.put("value",testClusternullableInt56sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt56sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt56sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt56sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt56sAttribute", writeTestClusterNullableInt56sAttributeInteractionInfo); - Map writeTestClusterNullableInt64sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableInt64sCommandParameterInfo = new CommandParameterInfo("value", Long.class); - writeTestClusterNullableInt64sCommandParams.put("value",testClusternullableInt64sCommandParameterInfo); - InteractionInfo writeTestClusterNullableInt64sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableInt64sAttribute( - (DefaultClusterCallback) callback, - (Long) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableInt64sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableInt64sAttribute", writeTestClusterNullableInt64sAttributeInteractionInfo); - Map writeTestClusterNullableEnum8CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableEnum8CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnum8CommandParams.put("value",testClusternullableEnum8CommandParameterInfo); - InteractionInfo writeTestClusterNullableEnum8AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableEnum8Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnum8CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableEnum8Attribute", writeTestClusterNullableEnum8AttributeInteractionInfo); - Map writeTestClusterNullableEnum16CommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableEnum16CommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnum16CommandParams.put("value",testClusternullableEnum16CommandParameterInfo); - InteractionInfo writeTestClusterNullableEnum16AttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableEnum16Attribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnum16CommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableEnum16Attribute", writeTestClusterNullableEnum16AttributeInteractionInfo); - Map writeTestClusterNullableFloatSingleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableFloatSingleCommandParameterInfo = new CommandParameterInfo("value", Float.class); - writeTestClusterNullableFloatSingleCommandParams.put("value",testClusternullableFloatSingleCommandParameterInfo); - InteractionInfo writeTestClusterNullableFloatSingleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableFloatSingleAttribute( - (DefaultClusterCallback) callback, - (Float) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableFloatSingleCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableFloatSingleAttribute", writeTestClusterNullableFloatSingleAttributeInteractionInfo); - Map writeTestClusterNullableFloatDoubleCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableFloatDoubleCommandParameterInfo = new CommandParameterInfo("value", Double.class); - writeTestClusterNullableFloatDoubleCommandParams.put("value",testClusternullableFloatDoubleCommandParameterInfo); - InteractionInfo writeTestClusterNullableFloatDoubleAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableFloatDoubleAttribute( - (DefaultClusterCallback) callback, - (Double) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableFloatDoubleCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableFloatDoubleAttribute", writeTestClusterNullableFloatDoubleAttributeInteractionInfo); - Map writeTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableOctetStringCommandParameterInfo = new CommandParameterInfo("value", byte[].class); - writeTestClusterNullableOctetStringCommandParams.put("value",testClusternullableOctetStringCommandParameterInfo); - InteractionInfo writeTestClusterNullableOctetStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableOctetStringAttribute( - (DefaultClusterCallback) callback, - (byte[]) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableOctetStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableOctetStringAttribute", writeTestClusterNullableOctetStringAttributeInteractionInfo); - Map writeTestClusterNullableCharStringCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableCharStringCommandParameterInfo = new CommandParameterInfo("value", String.class); - writeTestClusterNullableCharStringCommandParams.put("value",testClusternullableCharStringCommandParameterInfo); - InteractionInfo writeTestClusterNullableCharStringAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableCharStringAttribute( - (DefaultClusterCallback) callback, - (String) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableCharStringCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableCharStringAttribute", writeTestClusterNullableCharStringAttributeInteractionInfo); - Map writeTestClusterNullableEnumAttrCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableEnumAttrCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableEnumAttrCommandParams.put("value",testClusternullableEnumAttrCommandParameterInfo); - InteractionInfo writeTestClusterNullableEnumAttrAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableEnumAttrAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableEnumAttrCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableEnumAttrAttribute", writeTestClusterNullableEnumAttrAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt8uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt8uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt8uCommandParams.put("value",testClusternullableRangeRestrictedInt8uCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt8uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt8uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt8uAttribute", writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt8sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt8sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt8sCommandParams.put("value",testClusternullableRangeRestrictedInt8sCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt8sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt8sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt8sAttribute", writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt16uCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt16uCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt16uCommandParams.put("value",testClusternullableRangeRestrictedInt16uCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt16uAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt16uCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt16uAttribute", writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); - Map writeTestClusterNullableRangeRestrictedInt16sCommandParams = new LinkedHashMap(); - CommandParameterInfo testClusternullableRangeRestrictedInt16sCommandParameterInfo = new CommandParameterInfo("value", Integer.class); - writeTestClusterNullableRangeRestrictedInt16sCommandParams.put("value",testClusternullableRangeRestrictedInt16sCommandParameterInfo); - InteractionInfo writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = new InteractionInfo( - (cluster, callback, commandArguments) -> { - ((ChipClusters.TestClusterCluster) cluster).writeNullableRangeRestrictedInt16sAttribute( - (DefaultClusterCallback) callback, - (Integer) - commandArguments.get("value") - - ); - }, - () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), - writeTestClusterNullableRangeRestrictedInt16sCommandParams - ); - writeTestClusterInteractionInfo.put("writeNullableRangeRestrictedInt16sAttribute", writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); - writeAttributeMap.put("testCluster", writeTestClusterInteractionInfo); - Map writeThermostatInteractionInfo = new LinkedHashMap<>(); - Map writeThermostatOccupiedCoolingSetpointCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = new CommandParameterInfo("value", 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 writeThermostatMinHeatSetpointLimitCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = new CommandParameterInfo("value", 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 writeThermostatControlSequenceOfOperationCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatsystemModeCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); - Map writeThermostatUserInterfaceConfigurationInteractionInfo = new LinkedHashMap<>(); - Map writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = new LinkedHashMap(); - CommandParameterInfo thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = new CommandParameterInfo("value", 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); - 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); - Map writeThreadNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); - Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeTimeFormatLocalizationHourFormatCommandParams = new LinkedHashMap(); - CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = new CommandParameterInfo("value", 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(); - CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); - Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); - Map writeUnitLocalizationTemperatureUnitCommandParams = new LinkedHashMap(); - CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = new CommandParameterInfo("value", 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); - writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); - Map writeUserLabelInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("userLabel", writeUserLabelInteractionInfo); - Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); - Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); - writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); - Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); - Map writeWindowCoveringModeCommandParams = new LinkedHashMap(); - CommandParameterInfo windowCoveringmodeCommandParameterInfo = new CommandParameterInfo("value", 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 writeAccessControlInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("accessControl", writeAccessControlInteractionInfo); + Map writeAccountLoginInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("accountLogin", writeAccountLoginInteractionInfo); + Map writeAdministratorCommissioningInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "administratorCommissioning", writeAdministratorCommissioningInteractionInfo); + Map writeApplicationBasicInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("applicationBasic", writeApplicationBasicInteractionInfo); + Map writeApplicationLauncherInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("applicationLauncher", writeApplicationLauncherInteractionInfo); + Map writeAudioOutputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("audioOutput", writeAudioOutputInteractionInfo); + Map writeBarrierControlInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("barrierControl", writeBarrierControlInteractionInfo); + Map writeBasicInteractionInfo = new LinkedHashMap<>(); + Map writeBasicNodeLabelCommandParams = + new LinkedHashMap(); + CommandParameterInfo basicnodeLabelCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeBasicNodeLabelCommandParams.put("value", basicnodeLabelCommandParameterInfo); + InteractionInfo writeBasicNodeLabelAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .writeNodeLabelAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicNodeLabelCommandParams); + writeBasicInteractionInfo.put( + "writeNodeLabelAttribute", writeBasicNodeLabelAttributeInteractionInfo); + Map writeBasicLocationCommandParams = + new LinkedHashMap(); + CommandParameterInfo basiclocationCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeBasicLocationCommandParams.put("value", basiclocationCommandParameterInfo); + InteractionInfo writeBasicLocationAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .writeLocationAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicLocationCommandParams); + writeBasicInteractionInfo.put( + "writeLocationAttribute", writeBasicLocationAttributeInteractionInfo); + Map writeBasicLocalConfigDisabledCommandParams = + new LinkedHashMap(); + CommandParameterInfo basiclocalConfigDisabledCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeBasicLocalConfigDisabledCommandParams.put( + "value", basiclocalConfigDisabledCommandParameterInfo); + InteractionInfo writeBasicLocalConfigDisabledAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.BasicCluster) cluster) + .writeLocalConfigDisabledAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeBasicLocalConfigDisabledCommandParams); + writeBasicInteractionInfo.put( + "writeLocalConfigDisabledAttribute", writeBasicLocalConfigDisabledAttributeInteractionInfo); + writeAttributeMap.put("basic", writeBasicInteractionInfo); + Map writeBinaryInputBasicInteractionInfo = new LinkedHashMap<>(); + Map writeBinaryInputBasicOutOfServiceCommandParams = + new LinkedHashMap(); + CommandParameterInfo binaryInputBasicoutOfServiceCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo binaryInputBasicpresentValueCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("binaryInputBasic", writeBinaryInputBasicInteractionInfo); + Map writeBindingInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("binding", writeBindingInteractionInfo); + Map writeBooleanStateInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("booleanState", writeBooleanStateInteractionInfo); + Map writeBridgedActionsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bridgedActions", writeBridgedActionsInteractionInfo); + Map writeBridgedDeviceBasicInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("bridgedDeviceBasic", writeBridgedDeviceBasicInteractionInfo); + Map writeChannelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("channel", writeChannelInteractionInfo); + Map writeColorControlInteractionInfo = new LinkedHashMap<>(); + Map writeColorControlColorControlOptionsCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlcolorControlOptionsCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeColorControlColorControlOptionsCommandParams.put( + "value", colorControlcolorControlOptionsCommandParameterInfo); + InteractionInfo writeColorControlColorControlOptionsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.ColorControlCluster) cluster) + .writeColorControlOptionsAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeColorControlColorControlOptionsCommandParams); + writeColorControlInteractionInfo.put( + "writeColorControlOptionsAttribute", + writeColorControlColorControlOptionsAttributeInteractionInfo); + Map writeColorControlWhitePointXCommandParams = + new LinkedHashMap(); + CommandParameterInfo colorControlwhitePointXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlwhitePointYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointRIntensityCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointGIntensityCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBXCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBYCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlcolorPointBIntensityCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo colorControlstartUpColorTemperatureMiredsCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("colorControl", writeColorControlInteractionInfo); + Map writeContentLauncherInteractionInfo = new LinkedHashMap<>(); + Map writeContentLauncherSupportedStreamingProtocolsCommandParams = + new LinkedHashMap(); + CommandParameterInfo contentLaunchersupportedStreamingProtocolsCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("contentLauncher", writeContentLauncherInteractionInfo); + Map writeDescriptorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("descriptor", writeDescriptorInteractionInfo); + Map writeDiagnosticLogsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("diagnosticLogs", writeDiagnosticLogsInteractionInfo); + Map writeDoorLockInteractionInfo = new LinkedHashMap<>(); + Map writeDoorLockLanguageCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLocklanguageCommandParameterInfo = + new CommandParameterInfo("value", 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 writeDoorLockAutoRelockTimeCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockautoRelockTimeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo doorLocksoundVolumeCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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 writeDoorLockEnableOneTouchLockingCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockenableOneTouchLockingCommandParameterInfo = + new CommandParameterInfo("value", 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 writeDoorLockEnablePrivacyModeButtonCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockenablePrivacyModeButtonCommandParameterInfo = + new CommandParameterInfo("value", 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 writeDoorLockWrongCodeEntryLimitCommandParams = + new LinkedHashMap(); + CommandParameterInfo doorLockwrongCodeEntryLimitCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("doorLock", writeDoorLockInteractionInfo); + Map writeElectricalMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("electricalMeasurement", writeElectricalMeasurementInteractionInfo); + Map writeEthernetNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "ethernetNetworkDiagnostics", writeEthernetNetworkDiagnosticsInteractionInfo); + Map writeFixedLabelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("fixedLabel", writeFixedLabelInteractionInfo); + Map writeFlowMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("flowMeasurement", writeFlowMeasurementInteractionInfo); + Map writeGeneralCommissioningInteractionInfo = new LinkedHashMap<>(); + Map writeGeneralCommissioningBreadcrumbCommandParams = + new LinkedHashMap(); + CommandParameterInfo generalCommissioningbreadcrumbCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("generalCommissioning", writeGeneralCommissioningInteractionInfo); + Map writeGeneralDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("generalDiagnostics", writeGeneralDiagnosticsInteractionInfo); + Map writeGroupKeyManagementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("groupKeyManagement", writeGroupKeyManagementInteractionInfo); + Map writeGroupsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("groups", writeGroupsInteractionInfo); + Map writeIdentifyInteractionInfo = new LinkedHashMap<>(); + Map writeIdentifyIdentifyTimeCommandParams = + new LinkedHashMap(); + CommandParameterInfo identifyidentifyTimeCommandParameterInfo = + new CommandParameterInfo("value", 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 writeIlluminanceMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("illuminanceMeasurement", writeIlluminanceMeasurementInteractionInfo); + Map writeKeypadInputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("keypadInput", writeKeypadInputInteractionInfo); + Map writeLevelControlInteractionInfo = new LinkedHashMap<>(); + Map writeLevelControlOptionsCommandParams = + new LinkedHashMap(); + CommandParameterInfo levelControloptionsCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo levelControlonLevelCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo levelControloffTransitionTimeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo levelControldefaultMoveRateCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo levelControlstartUpCurrentLevelCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("levelControl", writeLevelControlInteractionInfo); + Map writeLocalizationConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map writeLocalizationConfigurationActiveLocaleCommandParams = + new LinkedHashMap(); + CommandParameterInfo localizationConfigurationactiveLocaleCommandParameterInfo = + new CommandParameterInfo("value", 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); + Map writeLowPowerInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("lowPower", writeLowPowerInteractionInfo); + Map writeMediaInputInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("mediaInput", writeMediaInputInteractionInfo); + Map writeMediaPlaybackInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("mediaPlayback", writeMediaPlaybackInteractionInfo); + Map writeModeSelectInteractionInfo = new LinkedHashMap<>(); + Map writeModeSelectOnModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo modeSelectonModeCommandParameterInfo = + new CommandParameterInfo("value", 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 writeNetworkCommissioningInteractionInfo = new LinkedHashMap<>(); + Map writeNetworkCommissioningInterfaceEnabledCommandParams = + new LinkedHashMap(); + CommandParameterInfo networkCommissioninginterfaceEnabledCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("networkCommissioning", writeNetworkCommissioningInteractionInfo); + Map writeOtaSoftwareUpdateProviderInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "otaSoftwareUpdateProvider", writeOtaSoftwareUpdateProviderInteractionInfo); + Map writeOtaSoftwareUpdateRequestorInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "otaSoftwareUpdateRequestor", writeOtaSoftwareUpdateRequestorInteractionInfo); + Map writeOccupancySensingInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("occupancySensing", writeOccupancySensingInteractionInfo); + Map writeOnOffInteractionInfo = new LinkedHashMap<>(); + Map writeOnOffOnTimeCommandParams = + new LinkedHashMap(); + CommandParameterInfo onOffonTimeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo onOffoffWaitTimeCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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(); + CommandParameterInfo onOffSwitchConfigurationswitchActionsCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("onOffSwitchConfiguration", writeOnOffSwitchConfigurationInteractionInfo); + Map writeOperationalCredentialsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("operationalCredentials", writeOperationalCredentialsInteractionInfo); + Map writePowerSourceInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("powerSource", writePowerSourceInteractionInfo); + Map writePowerSourceConfigurationInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put("powerSourceConfiguration", writePowerSourceConfigurationInteractionInfo); + Map writePressureMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("pressureMeasurement", writePressureMeasurementInteractionInfo); + Map writePumpConfigurationAndControlInteractionInfo = + new LinkedHashMap<>(); + Map + writePumpConfigurationAndControlLifetimeRunningHoursCommandParams = + new LinkedHashMap(); + CommandParameterInfo pumpConfigurationAndControllifetimeRunningHoursCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControllifetimeEnergyConsumedCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControloperationModeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo pumpConfigurationAndControlcontrolModeCommandParameterInfo = + new CommandParameterInfo("value", 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); + Map writeRelativeHumidityMeasurementInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put( + "relativeHumidityMeasurement", writeRelativeHumidityMeasurementInteractionInfo); + Map writeScenesInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("scenes", writeScenesInteractionInfo); + Map writeSoftwareDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("softwareDiagnostics", writeSoftwareDiagnosticsInteractionInfo); + Map writeSwitchInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("switch", writeSwitchInteractionInfo); + Map writeTargetNavigatorInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("targetNavigator", writeTargetNavigatorInteractionInfo); + Map writeTemperatureMeasurementInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("temperatureMeasurement", writeTemperatureMeasurementInteractionInfo); + Map writeTestClusterInteractionInfo = new LinkedHashMap<>(); + Map writeTestClusterBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterBooleanCommandParams.put("value", testClusterbooleanCommandParameterInfo); + InteractionInfo writeTestClusterBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeBooleanAttribute", writeTestClusterBooleanAttributeInteractionInfo); + Map writeTestClusterBitmap8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterBitmap8CommandParams.put("value", testClusterbitmap8CommandParameterInfo); + InteractionInfo writeTestClusterBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap8CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap8Attribute", writeTestClusterBitmap8AttributeInteractionInfo); + Map writeTestClusterBitmap16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterBitmap16CommandParams.put("value", testClusterbitmap16CommandParameterInfo); + InteractionInfo writeTestClusterBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap16CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap16Attribute", writeTestClusterBitmap16AttributeInteractionInfo); + Map writeTestClusterBitmap32CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap32CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterBitmap32CommandParams.put("value", testClusterbitmap32CommandParameterInfo); + InteractionInfo writeTestClusterBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap32Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap32CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap32Attribute", writeTestClusterBitmap32AttributeInteractionInfo); + Map writeTestClusterBitmap64CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterbitmap64CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterBitmap64CommandParams.put("value", testClusterbitmap64CommandParameterInfo); + InteractionInfo writeTestClusterBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeBitmap64Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterBitmap64CommandParams); + writeTestClusterInteractionInfo.put( + "writeBitmap64Attribute", writeTestClusterBitmap64AttributeInteractionInfo); + Map writeTestClusterInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt8uCommandParams.put("value", testClusterint8uCommandParameterInfo); + InteractionInfo writeTestClusterInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt8uAttribute", writeTestClusterInt8uAttributeInteractionInfo); + Map writeTestClusterInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt16uCommandParams.put("value", testClusterint16uCommandParameterInfo); + InteractionInfo writeTestClusterInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt16uAttribute", writeTestClusterInt16uAttributeInteractionInfo); + Map writeTestClusterInt24uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint24uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt24uCommandParams.put("value", testClusterint24uCommandParameterInfo); + InteractionInfo writeTestClusterInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt24uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt24uAttribute", writeTestClusterInt24uAttributeInteractionInfo); + Map writeTestClusterInt32uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint32uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt32uCommandParams.put("value", testClusterint32uCommandParameterInfo); + InteractionInfo writeTestClusterInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt32uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt32uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt32uAttribute", writeTestClusterInt32uAttributeInteractionInfo); + Map writeTestClusterInt40uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint40uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt40uCommandParams.put("value", testClusterint40uCommandParameterInfo); + InteractionInfo writeTestClusterInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt40uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt40uAttribute", writeTestClusterInt40uAttributeInteractionInfo); + Map writeTestClusterInt48uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint48uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt48uCommandParams.put("value", testClusterint48uCommandParameterInfo); + InteractionInfo writeTestClusterInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt48uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt48uAttribute", writeTestClusterInt48uAttributeInteractionInfo); + Map writeTestClusterInt56uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint56uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt56uCommandParams.put("value", testClusterint56uCommandParameterInfo); + InteractionInfo writeTestClusterInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt56uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt56uAttribute", writeTestClusterInt56uAttributeInteractionInfo); + Map writeTestClusterInt64uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint64uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt64uCommandParams.put("value", testClusterint64uCommandParameterInfo); + InteractionInfo writeTestClusterInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt64uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt64uCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt64uAttribute", writeTestClusterInt64uAttributeInteractionInfo); + Map writeTestClusterInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt8sCommandParams.put("value", testClusterint8sCommandParameterInfo); + InteractionInfo writeTestClusterInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt8sAttribute", writeTestClusterInt8sAttributeInteractionInfo); + Map writeTestClusterInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterInt16sCommandParams.put("value", testClusterint16sCommandParameterInfo); + InteractionInfo writeTestClusterInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt16sAttribute", writeTestClusterInt16sAttributeInteractionInfo); + Map writeTestClusterInt24sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint24sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt24sCommandParams.put("value", testClusterint24sCommandParameterInfo); + InteractionInfo writeTestClusterInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt24sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt24sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt24sAttribute", writeTestClusterInt24sAttributeInteractionInfo); + Map writeTestClusterInt32sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint32sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt32sCommandParams.put("value", testClusterint32sCommandParameterInfo); + InteractionInfo writeTestClusterInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt32sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt32sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt32sAttribute", writeTestClusterInt32sAttributeInteractionInfo); + Map writeTestClusterInt40sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint40sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt40sCommandParams.put("value", testClusterint40sCommandParameterInfo); + InteractionInfo writeTestClusterInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt40sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt40sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt40sAttribute", writeTestClusterInt40sAttributeInteractionInfo); + Map writeTestClusterInt48sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint48sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt48sCommandParams.put("value", testClusterint48sCommandParameterInfo); + InteractionInfo writeTestClusterInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt48sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt48sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt48sAttribute", writeTestClusterInt48sAttributeInteractionInfo); + Map writeTestClusterInt56sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint56sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt56sCommandParams.put("value", testClusterint56sCommandParameterInfo); + InteractionInfo writeTestClusterInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt56sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt56sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt56sAttribute", writeTestClusterInt56sAttributeInteractionInfo); + Map writeTestClusterInt64sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterint64sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterInt64sCommandParams.put("value", testClusterint64sCommandParameterInfo); + InteractionInfo writeTestClusterInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeInt64sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterInt64sCommandParams); + writeTestClusterInteractionInfo.put( + "writeInt64sAttribute", writeTestClusterInt64sAttributeInteractionInfo); + Map writeTestClusterEnum8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterenum8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterEnum8CommandParams.put("value", testClusterenum8CommandParameterInfo); + InteractionInfo writeTestClusterEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEnum8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnum8CommandParams); + writeTestClusterInteractionInfo.put( + "writeEnum8Attribute", writeTestClusterEnum8AttributeInteractionInfo); + Map writeTestClusterEnum16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterenum16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterEnum16CommandParams.put("value", testClusterenum16CommandParameterInfo); + InteractionInfo writeTestClusterEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEnum16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnum16CommandParams); + writeTestClusterInteractionInfo.put( + "writeEnum16Attribute", writeTestClusterEnum16AttributeInteractionInfo); + Map writeTestClusterFloatSingleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterfloatSingleCommandParameterInfo = + new CommandParameterInfo("value", Float.class); + writeTestClusterFloatSingleCommandParams.put( + "value", testClusterfloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeFloatSingleAttribute( + (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatSingleCommandParams); + writeTestClusterInteractionInfo.put( + "writeFloatSingleAttribute", writeTestClusterFloatSingleAttributeInteractionInfo); + Map writeTestClusterFloatDoubleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterfloatDoubleCommandParameterInfo = + new CommandParameterInfo("value", Double.class); + writeTestClusterFloatDoubleCommandParams.put( + "value", testClusterfloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeFloatDoubleAttribute( + (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatDoubleCommandParams); + writeTestClusterInteractionInfo.put( + "writeFloatDoubleAttribute", writeTestClusterFloatDoubleAttributeInteractionInfo); + Map writeTestClusterOctetStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusteroctetStringCommandParameterInfo = + new CommandParameterInfo("value", byte[].class); + writeTestClusterOctetStringCommandParams.put( + "value", testClusteroctetStringCommandParameterInfo); + InteractionInfo writeTestClusterOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterOctetStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeOctetStringAttribute", writeTestClusterOctetStringAttributeInteractionInfo); + Map writeTestClusterLongOctetStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterlongOctetStringCommandParameterInfo = + new CommandParameterInfo("value", byte[].class); + writeTestClusterLongOctetStringCommandParams.put( + "value", testClusterlongOctetStringCommandParameterInfo); + InteractionInfo writeTestClusterLongOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeLongOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterLongOctetStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeLongOctetStringAttribute", writeTestClusterLongOctetStringAttributeInteractionInfo); + Map writeTestClusterCharStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustercharStringCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeTestClusterCharStringCommandParams.put("value", testClustercharStringCommandParameterInfo); + InteractionInfo writeTestClusterCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterCharStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeCharStringAttribute", writeTestClusterCharStringAttributeInteractionInfo); + Map writeTestClusterLongCharStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterlongCharStringCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeTestClusterLongCharStringCommandParams.put( + "value", testClusterlongCharStringCommandParameterInfo); + InteractionInfo writeTestClusterLongCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeLongCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterLongCharStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeLongCharStringAttribute", writeTestClusterLongCharStringAttributeInteractionInfo); + Map writeTestClusterEpochUsCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterepochUsCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterEpochUsCommandParams.put("value", testClusterepochUsCommandParameterInfo); + InteractionInfo writeTestClusterEpochUsAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEpochUsAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEpochUsCommandParams); + writeTestClusterInteractionInfo.put( + "writeEpochUsAttribute", writeTestClusterEpochUsAttributeInteractionInfo); + Map writeTestClusterEpochSCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterepochSCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterEpochSCommandParams.put("value", testClusterepochSCommandParameterInfo); + InteractionInfo writeTestClusterEpochSAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEpochSAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEpochSCommandParams); + writeTestClusterInteractionInfo.put( + "writeEpochSAttribute", writeTestClusterEpochSAttributeInteractionInfo); + Map writeTestClusterVendorIdCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustervendorIdCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterVendorIdCommandParams.put("value", testClustervendorIdCommandParameterInfo); + InteractionInfo writeTestClusterVendorIdAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeVendorIdAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterVendorIdCommandParams); + writeTestClusterInteractionInfo.put( + "writeVendorIdAttribute", writeTestClusterVendorIdAttributeInteractionInfo); + Map writeTestClusterEnumAttrCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterenumAttrCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterEnumAttrCommandParams.put("value", testClusterenumAttrCommandParameterInfo); + InteractionInfo writeTestClusterEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeEnumAttrAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterEnumAttrCommandParams); + writeTestClusterInteractionInfo.put( + "writeEnumAttrAttribute", writeTestClusterEnumAttrAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt8uCommandParams.put( + "value", testClusterrangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt8uAttribute", + writeTestClusterRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt8sCommandParams.put( + "value", testClusterrangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt8sAttribute", + writeTestClusterRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt16uCommandParams.put( + "value", testClusterrangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt16uAttribute", + writeTestClusterRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterrangeRestrictedInt16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterRangeRestrictedInt16sCommandParams.put( + "value", testClusterrangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterRangeRestrictedInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeRangeRestrictedInt16sAttribute", + writeTestClusterRangeRestrictedInt16sAttributeInteractionInfo); + Map writeTestClusterTimedWriteBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustertimedWriteBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterTimedWriteBooleanCommandParams.put( + "value", testClustertimedWriteBooleanCommandParameterInfo); + InteractionInfo writeTestClusterTimedWriteBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeTimedWriteBooleanAttribute( + (DefaultClusterCallback) callback, + (Boolean) commandArguments.get("value"), + 10000); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterTimedWriteBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeTimedWriteBooleanAttribute", + writeTestClusterTimedWriteBooleanAttributeInteractionInfo); + Map writeTestClusterGeneralErrorBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustergeneralErrorBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterGeneralErrorBooleanCommandParams.put( + "value", testClustergeneralErrorBooleanCommandParameterInfo); + InteractionInfo writeTestClusterGeneralErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeGeneralErrorBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterGeneralErrorBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeGeneralErrorBooleanAttribute", + writeTestClusterGeneralErrorBooleanAttributeInteractionInfo); + Map writeTestClusterClusterErrorBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterclusterErrorBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterClusterErrorBooleanCommandParams.put( + "value", testClusterclusterErrorBooleanCommandParameterInfo); + InteractionInfo writeTestClusterClusterErrorBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeClusterErrorBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterClusterErrorBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeClusterErrorBooleanAttribute", + writeTestClusterClusterErrorBooleanAttributeInteractionInfo); + Map writeTestClusterUnsupportedCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterunsupportedCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterUnsupportedCommandParams.put( + "value", testClusterunsupportedCommandParameterInfo); + InteractionInfo writeTestClusterUnsupportedAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeUnsupportedAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterUnsupportedCommandParams); + writeTestClusterInteractionInfo.put( + "writeUnsupportedAttribute", writeTestClusterUnsupportedAttributeInteractionInfo); + Map writeTestClusterNullableBooleanCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBooleanCommandParameterInfo = + new CommandParameterInfo("value", Boolean.class); + writeTestClusterNullableBooleanCommandParams.put( + "value", testClusternullableBooleanCommandParameterInfo); + InteractionInfo writeTestClusterNullableBooleanAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBooleanAttribute( + (DefaultClusterCallback) callback, (Boolean) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBooleanCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBooleanAttribute", writeTestClusterNullableBooleanAttributeInteractionInfo); + Map writeTestClusterNullableBitmap8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableBitmap8CommandParams.put( + "value", testClusternullableBitmap8CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap8CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap8Attribute", writeTestClusterNullableBitmap8AttributeInteractionInfo); + Map writeTestClusterNullableBitmap16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableBitmap16CommandParams.put( + "value", testClusternullableBitmap16CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap16CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap16Attribute", writeTestClusterNullableBitmap16AttributeInteractionInfo); + Map writeTestClusterNullableBitmap32CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap32CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableBitmap32CommandParams.put( + "value", testClusternullableBitmap32CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap32AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap32Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap32CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap32Attribute", writeTestClusterNullableBitmap32AttributeInteractionInfo); + Map writeTestClusterNullableBitmap64CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableBitmap64CommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableBitmap64CommandParams.put( + "value", testClusternullableBitmap64CommandParameterInfo); + InteractionInfo writeTestClusterNullableBitmap64AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableBitmap64Attribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableBitmap64CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableBitmap64Attribute", writeTestClusterNullableBitmap64AttributeInteractionInfo); + Map writeTestClusterNullableInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt8uCommandParams.put( + "value", testClusternullableInt8uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt8uAttribute", writeTestClusterNullableInt8uAttributeInteractionInfo); + Map writeTestClusterNullableInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt16uCommandParams.put( + "value", testClusternullableInt16uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt16uAttribute", writeTestClusterNullableInt16uAttributeInteractionInfo); + Map writeTestClusterNullableInt24uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt24uCommandParams.put( + "value", testClusternullableInt24uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt24uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt24uAttribute", writeTestClusterNullableInt24uAttributeInteractionInfo); + Map writeTestClusterNullableInt32uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt32uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt32uCommandParams.put( + "value", testClusternullableInt32uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt32uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt32uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt32uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt32uAttribute", writeTestClusterNullableInt32uAttributeInteractionInfo); + Map writeTestClusterNullableInt40uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt40uCommandParams.put( + "value", testClusternullableInt40uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt40uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt40uAttribute", writeTestClusterNullableInt40uAttributeInteractionInfo); + Map writeTestClusterNullableInt48uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt48uCommandParams.put( + "value", testClusternullableInt48uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt48uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt48uAttribute", writeTestClusterNullableInt48uAttributeInteractionInfo); + Map writeTestClusterNullableInt56uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt56uCommandParams.put( + "value", testClusternullableInt56uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt56uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt56uAttribute", writeTestClusterNullableInt56uAttributeInteractionInfo); + Map writeTestClusterNullableInt64uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt64uCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt64uCommandParams.put( + "value", testClusternullableInt64uCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt64uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt64uAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt64uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt64uAttribute", writeTestClusterNullableInt64uAttributeInteractionInfo); + Map writeTestClusterNullableInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt8sCommandParams.put( + "value", testClusternullableInt8sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt8sAttribute", writeTestClusterNullableInt8sAttributeInteractionInfo); + Map writeTestClusterNullableInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableInt16sCommandParams.put( + "value", testClusternullableInt16sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt16sAttribute", writeTestClusterNullableInt16sAttributeInteractionInfo); + Map writeTestClusterNullableInt24sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt24sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt24sCommandParams.put( + "value", testClusternullableInt24sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt24sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt24sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt24sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt24sAttribute", writeTestClusterNullableInt24sAttributeInteractionInfo); + Map writeTestClusterNullableInt32sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt32sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt32sCommandParams.put( + "value", testClusternullableInt32sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt32sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt32sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt32sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt32sAttribute", writeTestClusterNullableInt32sAttributeInteractionInfo); + Map writeTestClusterNullableInt40sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt40sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt40sCommandParams.put( + "value", testClusternullableInt40sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt40sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt40sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt40sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt40sAttribute", writeTestClusterNullableInt40sAttributeInteractionInfo); + Map writeTestClusterNullableInt48sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt48sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt48sCommandParams.put( + "value", testClusternullableInt48sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt48sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt48sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt48sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt48sAttribute", writeTestClusterNullableInt48sAttributeInteractionInfo); + Map writeTestClusterNullableInt56sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt56sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt56sCommandParams.put( + "value", testClusternullableInt56sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt56sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt56sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt56sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt56sAttribute", writeTestClusterNullableInt56sAttributeInteractionInfo); + Map writeTestClusterNullableInt64sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableInt64sCommandParameterInfo = + new CommandParameterInfo("value", Long.class); + writeTestClusterNullableInt64sCommandParams.put( + "value", testClusternullableInt64sCommandParameterInfo); + InteractionInfo writeTestClusterNullableInt64sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableInt64sAttribute( + (DefaultClusterCallback) callback, (Long) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableInt64sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableInt64sAttribute", writeTestClusterNullableInt64sAttributeInteractionInfo); + Map writeTestClusterNullableEnum8CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableEnum8CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnum8CommandParams.put( + "value", testClusternullableEnum8CommandParameterInfo); + InteractionInfo writeTestClusterNullableEnum8AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableEnum8Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnum8CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableEnum8Attribute", writeTestClusterNullableEnum8AttributeInteractionInfo); + Map writeTestClusterNullableEnum16CommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableEnum16CommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnum16CommandParams.put( + "value", testClusternullableEnum16CommandParameterInfo); + InteractionInfo writeTestClusterNullableEnum16AttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableEnum16Attribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnum16CommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableEnum16Attribute", writeTestClusterNullableEnum16AttributeInteractionInfo); + Map writeTestClusterNullableFloatSingleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatSingleCommandParameterInfo = + new CommandParameterInfo("value", Float.class); + writeTestClusterNullableFloatSingleCommandParams.put( + "value", testClusternullableFloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableFloatSingleAttribute( + (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatSingleCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableFloatSingleAttribute", + writeTestClusterNullableFloatSingleAttributeInteractionInfo); + Map writeTestClusterNullableFloatDoubleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatDoubleCommandParameterInfo = + new CommandParameterInfo("value", Double.class); + writeTestClusterNullableFloatDoubleCommandParams.put( + "value", testClusternullableFloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableFloatDoubleAttribute( + (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatDoubleCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableFloatDoubleAttribute", + writeTestClusterNullableFloatDoubleAttributeInteractionInfo); + Map writeTestClusterNullableOctetStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableOctetStringCommandParameterInfo = + new CommandParameterInfo("value", byte[].class); + writeTestClusterNullableOctetStringCommandParams.put( + "value", testClusternullableOctetStringCommandParameterInfo); + InteractionInfo writeTestClusterNullableOctetStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableOctetStringAttribute( + (DefaultClusterCallback) callback, (byte[]) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableOctetStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableOctetStringAttribute", + writeTestClusterNullableOctetStringAttributeInteractionInfo); + Map writeTestClusterNullableCharStringCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableCharStringCommandParameterInfo = + new CommandParameterInfo("value", String.class); + writeTestClusterNullableCharStringCommandParams.put( + "value", testClusternullableCharStringCommandParameterInfo); + InteractionInfo writeTestClusterNullableCharStringAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableCharStringAttribute( + (DefaultClusterCallback) callback, (String) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableCharStringCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableCharStringAttribute", + writeTestClusterNullableCharStringAttributeInteractionInfo); + Map writeTestClusterNullableEnumAttrCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableEnumAttrCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableEnumAttrCommandParams.put( + "value", testClusternullableEnumAttrCommandParameterInfo); + InteractionInfo writeTestClusterNullableEnumAttrAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableEnumAttrAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableEnumAttrCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableEnumAttrAttribute", writeTestClusterNullableEnumAttrAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt8uCommandParams.put( + "value", testClusternullableRangeRestrictedInt8uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt8uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt8uAttribute", + writeTestClusterNullableRangeRestrictedInt8uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt8sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt8sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt8sCommandParams.put( + "value", testClusternullableRangeRestrictedInt8sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt8sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt8sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt8sAttribute", + writeTestClusterNullableRangeRestrictedInt8sAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16uCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16uCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt16uCommandParams.put( + "value", testClusternullableRangeRestrictedInt16uCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt16uAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16uCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt16uAttribute", + writeTestClusterNullableRangeRestrictedInt16uAttributeInteractionInfo); + Map writeTestClusterNullableRangeRestrictedInt16sCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableRangeRestrictedInt16sCommandParameterInfo = + new CommandParameterInfo("value", Integer.class); + writeTestClusterNullableRangeRestrictedInt16sCommandParams.put( + "value", testClusternullableRangeRestrictedInt16sCommandParameterInfo); + InteractionInfo writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableRangeRestrictedInt16sAttribute( + (DefaultClusterCallback) callback, (Integer) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableRangeRestrictedInt16sCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableRangeRestrictedInt16sAttribute", + writeTestClusterNullableRangeRestrictedInt16sAttributeInteractionInfo); + writeAttributeMap.put("testCluster", writeTestClusterInteractionInfo); + Map writeThermostatInteractionInfo = new LinkedHashMap<>(); + Map writeThermostatOccupiedCoolingSetpointCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatoccupiedCoolingSetpointCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatoccupiedHeatingSetpointCommandParameterInfo = + new CommandParameterInfo("value", 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 writeThermostatMinHeatSetpointLimitCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatminHeatSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatmaxHeatSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatminCoolSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatmaxCoolSetpointLimitCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatminSetpointDeadBandCommandParameterInfo = + new CommandParameterInfo("value", 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 writeThermostatControlSequenceOfOperationCommandParams = + new LinkedHashMap(); + CommandParameterInfo thermostatcontrolSequenceOfOperationCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatsystemModeCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("thermostat", writeThermostatInteractionInfo); + Map writeThermostatUserInterfaceConfigurationInteractionInfo = + new LinkedHashMap<>(); + Map + writeThermostatUserInterfaceConfigurationTemperatureDisplayModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo + thermostatUserInterfaceConfigurationtemperatureDisplayModeCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo thermostatUserInterfaceConfigurationkeypadLockoutCommandParameterInfo = + new CommandParameterInfo("value", 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); + 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); + Map writeThreadNetworkDiagnosticsInteractionInfo = + new LinkedHashMap<>(); + writeAttributeMap.put("threadNetworkDiagnostics", writeThreadNetworkDiagnosticsInteractionInfo); + Map writeTimeFormatLocalizationInteractionInfo = new LinkedHashMap<>(); + Map writeTimeFormatLocalizationHourFormatCommandParams = + new LinkedHashMap(); + CommandParameterInfo timeFormatLocalizationhourFormatCommandParameterInfo = + new CommandParameterInfo("value", 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(); + CommandParameterInfo timeFormatLocalizationactiveCalendarTypeCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("timeFormatLocalization", writeTimeFormatLocalizationInteractionInfo); + Map writeUnitLocalizationInteractionInfo = new LinkedHashMap<>(); + Map writeUnitLocalizationTemperatureUnitCommandParams = + new LinkedHashMap(); + CommandParameterInfo unitLocalizationtemperatureUnitCommandParameterInfo = + new CommandParameterInfo("value", 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); + writeAttributeMap.put("unitLocalization", writeUnitLocalizationInteractionInfo); + Map writeUserLabelInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("userLabel", writeUserLabelInteractionInfo); + Map writeWakeOnLanInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("wakeOnLan", writeWakeOnLanInteractionInfo); + Map writeWiFiNetworkDiagnosticsInteractionInfo = new LinkedHashMap<>(); + writeAttributeMap.put("wiFiNetworkDiagnostics", writeWiFiNetworkDiagnosticsInteractionInfo); + Map writeWindowCoveringInteractionInfo = new LinkedHashMap<>(); + Map writeWindowCoveringModeCommandParams = + new LinkedHashMap(); + CommandParameterInfo windowCoveringmodeCommandParameterInfo = + new CommandParameterInfo("value", 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); return writeAttributeMap; } }